613a85f · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Rename array fold and parsing routines

613a85fHarendra Kumar5 years ago

src/Streamly/Internal/Data/Array/Stream/Foreign.hs+25−23

compare with master

unifiedsplit

@@ -22,11 +22,13 @@ module Streamly.Internal.Data.Array.Stream.Foreign

22 , unlines

24 -- * Elimination

25− , fold

25+ -- ** Array Folds

26− , fold_

26+ , foldArr

27− -- , parse

27+ , foldArr_

28− , parseD

28+ -- , parseArr

29− , foldMany

29+ , parseArrD

30+ , foldArrMany

31+

30 , toArray

32 , toArray

32 -- * Compaction

34 -- * Compaction

@@ -465,13 +467,13 @@ _toArraysOf n = FL.chunksOf n (A.writeNF n) FL.toStream

465{-# ANN type List NoSpecConstr #-}

467{-# ANN type List NoSpecConstr #-}

466newtype List a = List {getList :: [a]}

468newtype List a = List {getList :: [a]}

467

469

468−{-# INLINE_NORMAL parseD #-}

470+{-# INLINE_NORMAL parseArrD #-}

469−parseD ::

471+parseArrD ::

470 forall m a b. (MonadIO m, MonadThrow m, Storable a)

472 forall m a b. (MonadIO m, MonadThrow m, Storable a)

471 => PRD.Parser m (Array a) b

473 => PRD.Parser m (Array a) b

472 -> D.Stream m (Array.Array a)

474 -> D.Stream m (Array.Array a)

473 -> m (b, D.Stream m (Array.Array a))

475 -> m (b, D.Stream m (Array.Array a))

474−parseD (PRD.Parser pstep initial extract) stream@(D.Stream step state) = do

476+parseArrD (PRD.Parser pstep initial extract) stream@(D.Stream step state) = do

475 res <- initial

477 res <- initial

476 case res of

478 case res of

477 PRD.IPartial s -> go SPEC state (List []) s

479 PRD.IPartial s -> go SPEC state (List []) s

@@ -535,32 +537,32 @@ parseD (PRD.Parser pstep initial extract) stream@(D.Stream step state) = do

535--

537--

536-- /Internal/

538-- /Internal/

537--

539--

538−{-# INLINE parse #-}

540+{-# INLINE parseArr #-}

539−parse ::

541+parseArr ::

540 (MonadIO m, MonadThrow m, Storable a)

542 (MonadIO m, MonadThrow m, Storable a)

541 => PRD.Parser m a b

543 => PRD.Parser m a b

542 -> SerialT m (A.Array a)

544 -> SerialT m (A.Array a)

543 -> m (b, SerialT m (A.Array a))

545 -> m (b, SerialT m (A.Array a))

544−parse p s = fmap D.fromStreamD <$> parseD p (D.toStreamD s)

546+parseArr p s = fmap D.fromStreamD <$> parseD p (D.toStreamD s)

545-}

547-}

546

548

547-- | Fold an array stream using the supplied array stream 'Fold'.

549-- | Fold an array stream using the supplied array stream 'Fold'.

548--

550--

549-- /Pre-release/

551-- /Pre-release/

550--

552--

551−{-# INLINE fold #-}

553+{-# INLINE foldArr #-}

552−fold :: (MonadIO m, MonadThrow m, Storable a) =>

554+foldArr :: (MonadIO m, MonadThrow m, Storable a) =>

553 ASF.Fold m a b -> SerialT m (A.Array a) -> m b

555 ASF.Fold m a b -> SerialT m (A.Array a) -> m b

554−fold (ASF.Fold p) s = fst <$> parseD p (D.toStreamD s)

556+foldArr (ASF.Fold p) s = fst <$> parseArrD p (D.toStreamD s)

555

557

556-- | Like 'fold' but also returns the remaining stream.

558-- | Like 'fold' but also returns the remaining stream.

557--

559--

558-- /Pre-release/

560-- /Pre-release/

559--

561--

560−{-# INLINE fold_ #-}

562+{-# INLINE foldArr_ #-}

561−fold_ :: (MonadIO m, MonadThrow m, Storable a) =>

563+foldArr_ :: (MonadIO m, MonadThrow m, Storable a) =>

562 ASF.Fold m a b -> SerialT m (A.Array a) -> m (b, SerialT m (A.Array a))

564 ASF.Fold m a b -> SerialT m (A.Array a) -> m (b, SerialT m (A.Array a))

563−fold_ (ASF.Fold p) s = second D.fromStreamD <$> parseD p (D.toStreamD s)

565+foldArr_ (ASF.Fold p) s = second D.fromStreamD <$> parseArrD p (D.toStreamD s)

564

566

565{-# ANN type ParseChunksState Fuse #-}

567{-# ANN type ParseChunksState Fuse #-}

566data ParseChunksState x inpBuf st pst =

568data ParseChunksState x inpBuf st pst =

@@ -570,13 +572,13 @@ data ParseChunksState x inpBuf st pst =

570 | ParseChunksBuf inpBuf st inpBuf !pst

572 | ParseChunksBuf inpBuf st inpBuf !pst

571 | ParseChunksYield x (ParseChunksState x inpBuf st pst)

573 | ParseChunksYield x (ParseChunksState x inpBuf st pst)

572

574

573−{-# INLINE_NORMAL foldManyD #-}

575+{-# INLINE_NORMAL foldArrManyD #-}

574−foldManyD

576+foldArrManyD

575 :: (MonadThrow m, Storable a)

577 :: (MonadThrow m, Storable a)

576 => ASF.Fold m a b

578 => ASF.Fold m a b

577 -> D.Stream m (Array a)

579 -> D.Stream m (Array a)

578 -> D.Stream m b

580 -> D.Stream m b

579−foldManyD (ASF.Fold (PRD.Parser pstep initial extract)) (D.Stream step state) =

581+foldArrManyD (ASF.Fold (PRD.Parser pstep initial extract)) (D.Stream step state) =

580 D.Stream stepOuter (ParseChunksInit [] state)

582 D.Stream stepOuter (ParseChunksInit [] state)

581

583

582 where

584 where

@@ -696,10 +698,10 @@ foldManyD (ASF.Fold (PRD.Parser pstep initial extract)) (D.Stream step state) =

696-- See "Streamly.Prelude.foldMany" for more details.

698-- See "Streamly.Prelude.foldMany" for more details.

697--

699--

698-- /Pre-release/

700-- /Pre-release/

699−{-# INLINE foldMany #-}

701+{-# INLINE foldArrMany #-}

700−foldMany

702+foldArrMany

701 :: (IsStream t, MonadThrow m, Storable a)

703 :: (IsStream t, MonadThrow m, Storable a)

702 => ASF.Fold m a b

704 => ASF.Fold m a b

703 -> t m (Array a)

705 -> t m (Array a)

704 -> t m b

706 -> t m b

705−foldMany p m = D.fromStreamD $ foldManyD p (D.toStreamD m)

707+foldArrMany p m = D.fromStreamD $ foldArrManyD p (D.toStreamD m)