e715e4a · streamly · git.iko.soy

git.iko.soy/streamly

Rename fold_/parse_/foldOn

fold_ to foldBreak foldOn to foldContinue parse_ to parseBreak Use Parser instead of ParserD in parseBreak API

commite715e4a11544873b1e4b89e1fcee17bacfc3ec0e authorHarendra Kumar <harendra@composewell.com> dateFri 13 May 2022, 22:21 (4 years ago) parent420f387

7 files changed+54−54

compare with master

unifiedsplit

core/src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hs+5−5 core/src/Streamly/Internal/Data/Stream/StreamD/Type.hs+9−9 src/Streamly/Internal/Data/Array/Stream/Foreign.hs+2−2 src/Streamly/Internal/Data/Stream/IsStream/Common.hs+15−15 src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs+13−13 test/Streamly/Test/Data/Array/Stream/Foreign.hs+6−6 test/Streamly/Test/Data/Fold.hs+4−4

core/src/Streamly/Internal/Data/Stream/StreamD/Eliminate.hs+5−5

@@ -17,7 +17,7 @@ module Streamly.Internal.Data.Stream.StreamD.Eliminate

1717

1818 -- -- * Running a 'Parser'

1919 , parse

20− , parse_

20+ , parseBreak

2121

2222 -- * Stream Deconstruction

2323 , uncons

@@ -141,17 +141,17 @@ parse

141141 -> Stream m a

142142 -> m b

143143parse parser strm = do

144− (b, _) <- parse_ parser strm

144+ (b, _) <- parseBreak parser strm

145145 return b

146146

147147-- | Run a 'Parse' over a stream and return rest of the Stream.

148−{-# INLINE_NORMAL parse_ #-}

149−parse_

148+{-# INLINE_NORMAL parseBreak #-}

149+parseBreak

150150 :: MonadThrow m

151151 => PRD.Parser m a b

152152 -> Stream m a

153153 -> m (b, Stream m a)

154−parse_ (PRD.Parser pstep initial extract) stream@(Stream step state) = do

154+parseBreak (PRD.Parser pstep initial extract) stream@(Stream step state) = do

155155 res <- initial

156156 case res of

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

core/src/Streamly/Internal/Data/Stream/StreamD/Type.hs+9−9

@@ -42,8 +42,8 @@ module Streamly.Internal.Data.Stream.StreamD.Type

4242

4343 -- * Running a 'Fold'

4444 , fold

45− , fold_

46− , foldOn

45+ , foldBreak

46+ , foldContinue

4747

4848 -- * Right Folds

4949 , foldrT

@@ -268,12 +268,12 @@ toStreamK (Stream step state) = go state

268268{-# INLINE_NORMAL fold #-}

269269fold :: Monad m => Fold m a b -> Stream m a -> m b

270270fold fld strm = do

271− (b, _) <- fold_ fld strm

271+ (b, _) <- foldBreak fld strm

272272 return b

273273

274−{-# INLINE_NORMAL fold_ #-}

275−fold_ :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)

276−fold_ (Fold fstep begin done) (Stream step state) = do

274+{-# INLINE_NORMAL foldBreak #-}

275+foldBreak :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)

276+foldBreak (Fold fstep begin done) (Stream step state) = do

277277 res <- begin

278278 case res of

279279 FL.Partial fs -> go SPEC fs state

@@ -295,9 +295,9 @@ fold_ (Fold fstep begin done) (Stream step state) = do

295295 b <- done fs

296296 return $! (b, Stream (\ _ _ -> return Stop) ())

297297

298−{-# INLINE_NORMAL foldOn #-}

299−foldOn :: Monad m => Fold m a b -> Stream m a -> Fold m a b

300−foldOn (Fold fstep finitial fextract) (Stream sstep state) =

298+{-# INLINE_NORMAL foldContinue #-}

299+foldContinue :: Monad m => Fold m a b -> Stream m a -> Fold m a b

300+foldContinue (Fold fstep finitial fextract) (Stream sstep state) =

301301 Fold fstep initial fextract

302302

303303 where

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

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

611611{-# INLINE_NORMAL parse #-}

612612parse ::

613613 (MonadIO m, MonadThrow m, Storable a)

614− => PRD.Parser m a b

614+ => PR.Parser m a b

615615 -> SerialT m (A.Array a)

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

617−parse p s = fmap fromStreamD <$> parseD p (toStreamD s)

617+parse p s = fmap fromStreamD <$> parseD (PRD.fromParserK p) (toStreamD s)

618618

619619-------------------------------------------------------------------------------

620620-- Elimination - Running Array Folds and parsers

src/Streamly/Internal/Data/Stream/IsStream/Common.hs+15−15

@@ -22,9 +22,9 @@ module Streamly.Internal.Data.Stream.IsStream.Common

2222 , relTimesWith

2323

2424 -- * Elimination

25− , foldOn

25+ , foldContinue

2626 , fold

27− , fold_

27+ , foldBreak

2828

2929 -- * Transformation

3030 , map

@@ -270,18 +270,18 @@ relTimesWith = fmap snd . timesWith

270270-- Elimination - Running a Fold

271271------------------------------------------------------------------------------

272272

273−-- | We can create higher order folds using 'foldOn'. We can fold a number of

274−-- streams to a given fold efficiently with full stream fusion. For example, to

275−-- fold a list of streams on the same sum fold:

273+-- | We can create higher order folds using 'foldContinue'. We can fold a

274+-- number of streams to a given fold efficiently with full stream fusion. For

275+-- example, to fold a list of streams on the same sum fold:

276276--

277−-- >>> concatFold = Prelude.foldl Stream.foldOn Fold.sum

277+-- >>> concatFold = Prelude.foldl Stream.foldContinue Fold.sum

278278--

279−-- >>> fold f = Fold.finish . Stream.foldOn f

279+-- >>> fold f = Fold.finish . Stream.foldContinue f

280280--

281281-- /Internal/

282−{-# INLINE foldOn #-}

283−foldOn :: Monad m => Fold m a b -> SerialT m a -> Fold m a b

284−foldOn f s = D.foldOn f $ IsStream.toStreamD s

282+{-# INLINE foldContinue #-}

283+foldContinue :: Monad m => Fold m a b -> SerialT m a -> Fold m a b

284+foldContinue f s = D.foldContinue f $ IsStream.toStreamD s

285285

286286-- | Fold a stream using the supplied left 'Fold' and reducing the resulting

287287-- expression strictly at each step. The behavior is similar to 'foldl''. A

@@ -308,13 +308,13 @@ foldOn f s = D.foldOn f $ IsStream.toStreamD s

308308{-# INLINE fold #-}

309309fold :: Monad m => Fold m a b -> SerialT m a -> m b

310310fold fl strm = do

311− (b, _) <- fold_ fl strm

311+ (b, _) <- foldBreak fl strm

312312 return $! b

313313

314−{-# INLINE fold_ #-}

315−fold_ :: Monad m => Fold m a b -> SerialT m a -> m (b, SerialT m a)

316−fold_ fl strm = do

317− (b, str) <- D.fold_ fl $ IsStream.toStreamD strm

314+{-# INLINE foldBreak #-}

315+foldBreak :: Monad m => Fold m a b -> SerialT m a -> m (b, SerialT m a)

316+foldBreak fl strm = do

317+ (b, str) <- D.foldBreak fl $ IsStream.toStreamD strm

318318 return $! (b, IsStream.fromStreamD str)

319319

320320------------------------------------------------------------------------------

src/Streamly/Internal/Data/Stream/IsStream/Eliminate.hs+13−13

@@ -23,16 +23,16 @@ module Streamly.Internal.Data.Stream.IsStream.Eliminate

2323 -- * Running a 'Fold'

2424 -- See "Streamly.Internal.Data.Fold".

2525 fold

26− , fold_

27− , foldOn

26+ , foldBreak

27+ , foldContinue

2828

2929 -- * Running a 'Parser'

3030 -- "Streamly.Internal.Data.Parser".

3131 , parse

3232 , parseK

3333 , parseD

34− , parse_

35− , parseD_

34+ , parseBreak

35+ , parseBreakD

3636

3737 -- * Stream Deconstruction

3838 -- | foldr and foldl do not provide the remaining stream. 'uncons' is more

@@ -162,8 +162,8 @@ import Streamly.Internal.Control.Concurrent (MonadAsync)

162162import Streamly.Internal.Data.Parser (Parser (..))

163163import Streamly.Internal.Data.SVar (defState)

164164import Streamly.Internal.Data.Stream.IsStream.Common

165− ( fold, fold_, foldOn, drop, findIndices, reverse, splitOnSeq, take

166− , takeWhile, mkParallel)

165+ ( fold, foldBreak, foldContinue, drop, findIndices, reverse, splitOnSeq

166+ , take , takeWhile, mkParallel)

167167import Streamly.Internal.Data.Stream.IsStream.Type

168168 (IsStream, toStreamS, fromStreamD, toStreamD)

169169import Streamly.Internal.Data.Stream.Serial (SerialT(..))

@@ -405,19 +405,19 @@ parseK = parse

405405parse :: MonadThrow m => Parser m a b -> SerialT m a -> m b

406406parse = parseD . PRD.fromParserK

407407

408−{-# INLINE_NORMAL parseD_ #-}

409−parseD_ :: MonadThrow m => PRD.Parser m a b -> SerialT m a -> m (b, SerialT m a)

410−parseD_ parser strm = do

411− (b, strmD) <- D.parse_ parser (toStreamD strm)

408+{-# INLINE_NORMAL parseBreakD #-}

409+parseBreakD :: MonadThrow m => PRD.Parser m a b -> SerialT m a -> m (b, SerialT m a)

410+parseBreakD parser strm = do

411+ (b, strmD) <- D.parseBreak parser (toStreamD strm)

412412 return $! (b, fromStreamD strmD)

413413

414414-- | Parse a stream using the supplied 'Parser'.

415415--

416416-- /Internal/

417417--

418−{-# INLINE [3] parse_ #-}

419−parse_ :: MonadThrow m => Parser m a b -> SerialT m a -> m (b, SerialT m a)

420−parse_ = parseD_ . PRD.fromParserK

418+{-# INLINE [3] parseBreak #-}

419+parseBreak :: MonadThrow m => Parser m a b -> SerialT m a -> m (b, SerialT m a)

420+parseBreak = parseBreakD . PRD.fromParserK

421421

422422------------------------------------------------------------------------------

423423-- Specific Fold Functions

test/Streamly/Test/Data/Array/Stream/Foreign.hs+6−6

@@ -9,7 +9,7 @@ import Test.QuickCheck.Monadic (monadicIO, run)

99import qualified Streamly.Internal.Data.Array.Foreign as Array

1010import qualified Streamly.Internal.Data.Array.Stream.Foreign as ArrayStream

1111import qualified Streamly.Internal.Data.Fold as Fold

12−import qualified Streamly.Internal.Data.Parser.ParserD as ParserD

12+import qualified Streamly.Internal.Data.Parser as Parser

1313import qualified Streamly.Internal.Data.Stream.IsStream as Stream

1414import qualified Test.Hspec as Hspec

1515

@@ -33,8 +33,8 @@ chooseAny = MkGen (\r _ -> let (x,_) = random r in x)

3333maxTestCount :: Int

3434maxTestCount = 100

3535

36−parse :: Property

37−parse = do

36+parseBreak :: Property

37+parseBreak = do

3838 let len = 200

3939 -- ls = input list (stream)

4040 -- clen = chunk size

@@ -50,8 +50,8 @@ parse = do

5050 let input =

5151 Stream.chunksOf

5252 clen (Array.writeN clen) (Stream.fromList ls)

53− parser = ParserD.fromFold (Fold.take tlen Fold.toList)

54− in run $ ArrayStream.parse parser input

53+ parser = Parser.fromFold (Fold.take tlen Fold.toList)

54+ in run $ ArrayStream.parseBreak parser input

5555 ls2 <- run $ Stream.toList $ ArrayStream.concat str

5656 listEquals (==) (ls1 ++ ls2) ls

5757

@@ -69,4 +69,4 @@ main =

6969 modifyMaxSuccess (const maxTestCount) $ do

7070 describe moduleName $ do

7171 describe "Stream parsing" $ do

72− prop "parse" parse

72+ prop "parseBreak" parseBreak

test/Streamly/Test/Data/Fold.hs+4−4

@@ -547,9 +547,9 @@ many =

547547

548548 split i = FL.take i FL.toList

549549

550−headAndRest :: [Int] -> Property

551−headAndRest ls = monadicIO $ do

552− (mbh, rest) <- run $ Stream.fold_ FL.head (S.fromList ls)

550+foldBreak :: [Int] -> Property

551+foldBreak ls = monadicIO $ do

552+ (mbh, rest) <- run $ Stream.foldBreak FL.head (S.fromList ls)

553553 rests <- run $ S.toList rest

554554 assert (mbh == headl ls)

555555 listEquals (==) rests (taill ls)

@@ -769,4 +769,4 @@ main = hspec $ do

769769 -- concatMap

770770 -- chunksOf

771771

772− prop "head from fold_" headAndRest

772+ prop "foldBreak" foldBreak