@@ -1,10 +1,3 @@
1−{-# OPTIONS_GHC -Wno-deprecations #-}
5−{-# OPTIONS_GHC -ddump-simpl -ddump-to-file -dsuppress-all #-}
9-- Module : Streamly.Benchmark.Data.Parser
2-- Module : Streamly.Benchmark.Data.Parser
10-- Copyright : (c) 2020 Composewell Technologies
3-- Copyright : (c) 2020 Composewell Technologies
@@ -14,42 +7,39 @@
15{-# LANGUAGE CPP #-}
8{-# LANGUAGE CPP #-}
16{-# LANGUAGE FlexibleContexts #-}
9{-# LANGUAGE FlexibleContexts #-}
17−{-# LANGUAGE ScopedTypeVariables #-}
18−{-# OPTIONS_GHC -Wno-orphans #-}
20module Main
11module Main
25−import Control.Applicative ((<|>))
26import Control.DeepSeq (NFData(..))
16import Control.DeepSeq (NFData(..))
27−import Data.Function ((&))
17+import Control.Monad.Catch (MonadCatch)
18+import Data.Foldable (asum)
28import Data.Functor (($>))
19import Data.Functor (($>))
20+import Data.Maybe (fromMaybe)
29import Data.Monoid (Sum(..))
21import Data.Monoid (Sum(..))
30import GHC.Magic (inline)
22import GHC.Magic (inline)
31import GHC.Magic (noinline)
23import GHC.Magic (noinline)
32import System.IO (Handle)
24import System.IO (Handle)
33import System.Random (randomRIO)
25import System.Random (randomRIO)
34−import Streamly.Internal.Data.Fold (Fold(..))
35−import Streamly.Internal.Data.Parser
36− (ParseError(..), Parser(..), Initial(..), Step(..))
37−import Streamly.Internal.Data.Stream (Stream)
38−import Prelude hiding
26+import Prelude
39− (any, all, take, sequence, sequence_, sequenceA, takeWhile, dropWhile, span)
27+ hiding (any, all, take, sequence, sequence_, sequenceA, takeWhile)
41−import qualified Control.Applicative as AP
42−import qualified Data.Foldable as F
43import qualified Data.Traversable as TR
29import qualified Data.Traversable as TR
30+import qualified Data.Foldable as F
31+import qualified Control.Applicative as AP
44import qualified Streamly.FileSystem.Handle as Handle
32import qualified Streamly.FileSystem.Handle as Handle
45−import qualified Streamly.Internal.Data.Array as Array
33+import qualified Streamly.Prelude as S
34+import qualified Streamly.Internal.Data.Array.Foreign as Array
46−import qualified Streamly.Internal.Data.Fold as Fold
35+import qualified Streamly.Internal.Data.Fold as FL
47import qualified Streamly.Internal.Data.Parser as PR
36import qualified Streamly.Internal.Data.Parser as PR
48−import qualified Streamly.Data.Stream as Stream
37+import qualified Streamly.Internal.Data.Stream.IsStream as IP
49import qualified Streamly.Internal.Data.Producer as Producer
38import qualified Streamly.Internal.Data.Producer as Producer
50−import qualified Streamly.Internal.Data.Stream as Stream
39+import qualified Streamly.Internal.Data.Producer.Source as Source
52−import Test.Tasty.Bench hiding (env)
41+import Gauge hiding (env)
42+import Streamly.Prelude (SerialT)
53import Streamly.Benchmark.Common
43import Streamly.Benchmark.Common
54import Streamly.Benchmark.Common.Handle
44import Streamly.Benchmark.Common.Handle
@@ -60,59 +50,19 @@ import Streamly.Benchmark.Common.Handle
60-- XXX these can be moved to the common module
50-- XXX these can be moved to the common module
62{-# INLINE sourceUnfoldrM #-}
52{-# INLINE sourceUnfoldrM #-}
63−sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int
53+sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
64−sourceUnfoldrM value n = Stream.unfoldrM step n
54+sourceUnfoldrM value n = S.unfoldrM step n
66 step cnt =
56 step cnt =
67 if cnt > n + value
57 if cnt > n + value
68 then return Nothing
58 then return Nothing
69 else return (Just (cnt, cnt + 1))
59 else return (Just (cnt, cnt + 1))
71−-- | Generates something like this: { { \{ \{ } }. The stream consists of
72−-- three parts, the first part is contains a sequence of `{`. The second part
73−-- contains a sequence pf escaped values `\{`. The third part contains a
75−{-# INLINE sourceEscapedFrames #-}
76−sourceEscapedFrames ::
81−sourceEscapedFrames value n = Stream.unfoldrM step n
87− value1 = value `div` 4
90− | cnt > 4 * value1 = return Nothing
91− | cnt <= value1 = return $ Just (cbOpen, cnt + 1)
92− | cnt > 3 * value1 = return $ Just (cbClose, cnt + 1)
96− $ if (cnt - value1) `mod` 2 == 1
98− else (cbOpen, cnt + 1)
100−{-# INLINE benchIOSrc #-}
103− => (Int -> Int -> Stream IO a)
106− -> (Stream IO a -> IO b)
108−benchIOSrc src value name f =
109− bench name $ nfIO $ randomRIO (1,1) >>= f . src value
111-- | Takes a fold method, and uses it with a default source.
61-- | Takes a fold method, and uses it with a default source.
112{-# INLINE benchIOSink #-}
62{-# INLINE benchIOSink #-}
113benchIOSink
63benchIOSink
114− :: NFData b
64+ :: (S.IsStream t, NFData b)
115− => Int -> String -> (Stream IO Int -> IO b) -> Benchmark
65+ => Int -> String -> (t IO Int -> IO b) -> Benchmark
116benchIOSink value name f =
66benchIOSink value name f =
117 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value
67 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value
@@ -120,452 +70,199 @@ benchIOSink value name f =
120-- Parsers
70-- Parsers
121-------------------------------------------------------------------------------
71-------------------------------------------------------------------------------
74+next :: MonadCatch m => Int -> SerialT m Int -> m (Maybe Int)
75+next value = IP.parse p
80+ Just i -> if i >= value then pure m else p
81+ Nothing -> pure Nothing
123{-# INLINE takeBetween #-}
83{-# INLINE takeBetween #-}
124−takeBetween :: Monad m => Int -> Stream m a -> m (Either ParseError ())
84+takeBetween :: MonadCatch m => Int -> SerialT m a -> m ()
125−takeBetween value = Stream.parse (PR.takeBetween 0 value Fold.drain)
85+takeBetween value = IP.parse (PR.takeBetween 0 value FL.drain)
127{-# INLINE takeEQ #-}
87{-# INLINE takeEQ #-}
128−takeEQ :: Monad m => Int -> Stream m a -> m (Either ParseError ())
88+takeEQ :: MonadCatch m => Int -> SerialT m a -> m ()
129−takeEQ value = Stream.parse (PR.takeEQ value Fold.drain)
89+takeEQ value = IP.parse (PR.takeEQ value FL.drain)
131−{-# INLINE takeGE #-}
132−takeGE :: Monad m => Int -> Stream m a -> m (Either ParseError ())
133−takeGE value = Stream.parse (PR.takeGE value Fold.drain)
135−{-# INLINE dropWhile #-}
91+{-# INLINE drainWhile #-}
136−dropWhile :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
92+drainWhile :: MonadCatch m => Int -> SerialT m Int -> m ()
137−dropWhile value = Stream.parse (PR.dropWhile (<= value))
93+drainWhile value = IP.parse (PR.drainWhile (<= value))
139−{-# INLINE takeStartBy #-}
95+{-# INLINE sliceBeginWith #-}
140−takeStartBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
96+sliceBeginWith :: MonadCatch m => Int -> SerialT m Int -> m ()
141−takeStartBy value stream = do
97+sliceBeginWith value stream = do
98+ stream1 <- return . fromMaybe (S.fromPure (value + 1)) =<< S.tail stream
142− let stream2 = value `Stream.cons` stream
99+ let stream2 = value `S.cons` stream1
143− Stream.parse (PR.takeStartBy (== value) Fold.drain) stream2
100+ IP.parse (PR.sliceBeginWith (== value) FL.drain) stream2
145−takeFramedByEsc_ :: Monad m => Int -> Stream m Char -> m (Either ParseError ())
146−takeFramedByEsc_ _ = Stream.parse parser
154− parser = PR.takeFramedByEsc_ isEsc isBegin isEnd Fold.drain
156−{-# INLINE listEqBy #-}
157−listEqBy :: Int -> Stream IO Int -> IO (Either ParseError [Int])
158−listEqBy len = Stream.parse (PR.listEqBy (==) [1 .. len])
160−{-# INLINE streamEqBy #-}
161−streamEqBy :: Int -> Stream IO Int -> IO (Either ParseError ())
162−streamEqBy len = Stream.parse (PR.streamEqBy (==) (Stream.enumerateFromTo 1 len))
164{-# INLINE takeWhile #-}
102{-# INLINE takeWhile #-}
165−takeWhile :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
103+takeWhile :: MonadCatch m => Int -> SerialT m Int -> m ()
166−takeWhile value = Stream.parse (PR.takeWhile (<= value) Fold.drain)
168−takeWhileP :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
170− Stream.parse (PR.takeWhileP (<= value) (PR.takeWhile (<= value - 1) Fold.drain))
104+takeWhile value = IP.parse (PR.takeWhile (<= value) FL.drain)
172{-# INLINE takeP #-}
106{-# INLINE takeP #-}
173−takeP :: Monad m => Int -> Stream m a -> m (Either ParseError ())
107+takeP :: MonadCatch m => Int -> SerialT m a -> m ()
174−takeP value = Stream.parse (PR.takeP value (PR.fromFold Fold.drain))
108+takeP value = IP.parse (PR.takeP value (PR.fromFold FL.drain))
176{-# INLINE groupBy #-}
110{-# INLINE groupBy #-}
177−groupBy :: Monad m => Stream m Int -> m (Either ParseError ())
111+groupBy :: MonadCatch m => SerialT m Int -> m ()
178−groupBy = Stream.parse (PR.groupBy (<=) Fold.drain)
112+groupBy = IP.parse (PR.groupBy (<=) FL.drain)
180{-# INLINE groupByRolling #-}
114{-# INLINE groupByRolling #-}
181−groupByRolling :: Monad m => Stream m Int -> m (Either ParseError ())
115+groupByRolling :: MonadCatch m => SerialT m Int -> m ()
182−groupByRolling = Stream.parse (PR.groupByRolling (<=) Fold.drain)
116+groupByRolling = IP.parse (PR.groupByRolling (<=) FL.drain)
184{-# INLINE wordBy #-}
118{-# INLINE wordBy #-}
185−wordBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
119+wordBy :: MonadCatch m => Int -> SerialT m Int -> m ()
186−wordBy value = Stream.parse (PR.wordBy (>= value) Fold.drain)
120+wordBy value = IP.parse (PR.wordBy (>= value) FL.drain)
188−{-# INLINE sepByWords #-}
189−sepByWords :: Monad m => Stream m Int -> m (Either ParseError ())
190−sepByWords = Stream.parse (wrds even Fold.drain)
192− wrds p = PR.sepBy (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)
194−{-# INLINE sepByAllWords #-}
195−sepByAllWords :: Monad m => Stream m Int -> m (Either ParseError ())
196−sepByAllWords = Stream.parse (wrds even Fold.drain)
198− wrds p = PR.sepByAll (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)
200−-- Returning a list to compare with the sepBy1 in ParserK
201−{-# INLINE sepBy1 #-}
202−sepBy1 :: Monad m => Stream m Int -> m (Either ParseError [Int])
204− Stream.parse (PR.sepBy1 (PR.satisfy odd) (PR.satisfy even) Fold.toList) xs
206−{-# INLINE sepByWords1 #-}
207−sepByWords1 :: Monad m => Stream m Int -> m (Either ParseError ())
208−sepByWords1 = Stream.parse (wrds even Fold.drain)
210− wrds p = PR.sepBy1 (PR.takeWhile (not . p) Fold.drain) (PR.dropWhile p)
212−{-# INLINE deintercalate #-}
213−deintercalate :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
214−deintercalate _ = Stream.parse (partition even)
220− (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum) Fold.drain
222−{-# INLINE deintercalate1 #-}
223−deintercalate1 :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
224−deintercalate1 _ = Stream.parse (partition even)
230− (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum) Fold.drain
232−{-# INLINE deintercalateAll #-}
233−deintercalateAll :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
234−deintercalateAll _ = Stream.parse (partition even)
240− (PR.takeWhile (not . p) Fold.sum) (PR.takeWhile p Fold.sum) Fold.drain
242{-# INLINE manyWordByEven #-}
122{-# INLINE manyWordByEven #-}
243−manyWordByEven :: Monad m => Stream m Int -> m (Either ParseError ())
123+manyWordByEven :: MonadCatch m => SerialT m Int -> m ()
244−manyWordByEven = Stream.parse (PR.many (PR.wordBy even Fold.drain) Fold.drain)
124+manyWordByEven = IP.parse (PR.many (PR.wordBy (Prelude.even) FL.drain) FL.drain)
246{-# INLINE many #-}
126{-# INLINE many #-}
247−many :: Monad m => Stream m Int -> m (Either ParseError Int)
127+many :: MonadCatch m => SerialT m Int -> m Int
248−many = Stream.parse (PR.many (PR.satisfy (> 0)) Fold.length)
128+many = IP.parse (PR.many (PR.satisfy (> 0)) FL.length)
250{-# INLINE manyAlt #-}
130{-# INLINE manyAlt #-}
251−manyAlt :: Monad m => Stream m Int -> m Int
131+manyAlt :: MonadCatch m => SerialT m Int -> m Int
252manyAlt xs = do
132manyAlt xs = do
253− x <- Stream.parse (AP.many (PR.satisfy (> 0))) xs
133+ x <- IP.parse (AP.many (PR.satisfy (> 0))) xs
254 return $ Prelude.length x
134 return $ Prelude.length x
256{-# INLINE some #-}
136{-# INLINE some #-}
257−some :: Monad m => Stream m Int -> m (Either ParseError Int)
137+some :: MonadCatch m => SerialT m Int -> m Int
258−some = Stream.parse (PR.some (PR.satisfy (> 0)) Fold.length)
138+some = IP.parse (PR.some (PR.satisfy (> 0)) FL.length)
260{-# INLINE someAlt #-}
140{-# INLINE someAlt #-}
261−someAlt :: Monad m => Stream m Int -> m Int
141+someAlt :: MonadCatch m => SerialT m Int -> m Int
262someAlt xs = do
142someAlt xs = do
263− x <- Stream.parse (AP.some (PR.satisfy (> 0))) xs
143+ x <- IP.parse (AP.some (PR.satisfy (> 0))) xs
264 return $ Prelude.length x
144 return $ Prelude.length x
266{-# INLINE manyTill #-}
146{-# INLINE manyTill #-}
267−manyTill :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)
147+manyTill :: MonadCatch m => Int -> SerialT m Int -> m Int
268manyTill value =
148manyTill value =
269− Stream.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) Fold.length)
149+ IP.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) FL.length)
271−{-# INLINE splitAp2 #-}
151+{-# INLINE splitAp #-}
272−splitAp2 :: Monad m
152+splitAp :: MonadCatch m
273− => Int -> Stream m Int -> m (Either ParseError ((), ()))
153+ => Int -> SerialT m Int -> m ((), ())
274−splitAp2 value =
154+splitAp value =
275− Stream.parse
155+ IP.parse
277− <$> PR.dropWhile (<= (value `div` 2))
157+ <$> PR.drainWhile (<= (value `div` 2))
278− <*> PR.dropWhile (<= value)
158+ <*> PR.drainWhile (<= value)
281−{-# INLINE splitAp4 #-}
283− => Int -> Stream m Int -> m (Either ParseError ())
286− ( (\() () () () -> ())
287− <$> PR.dropWhile (<= (value * 1 `div` 4))
288− <*> PR.dropWhile (<= (value * 2 `div` 4))
289− <*> PR.dropWhile (<= (value * 3 `div` 4))
290− <*> PR.dropWhile (<= value)
293−{-# INLINE splitAp8 #-}
295− => Int -> Stream m Int -> m (Either ParseError ())
298− ( (\() () () () () () () () -> ())
299− <$> PR.dropWhile (<= (value * 1 `div` 8))
300− <*> PR.dropWhile (<= (value * 2 `div` 8))
301− <*> PR.dropWhile (<= (value * 3 `div` 8))
302− <*> PR.dropWhile (<= (value * 4 `div` 8))
303− <*> PR.dropWhile (<= (value * 5 `div` 8))
304− <*> PR.dropWhile (<= (value * 6 `div` 8))
305− <*> PR.dropWhile (<= (value * 7 `div` 8))
306− <*> PR.dropWhile (<= value)
309{-# INLINE splitApBefore #-}
161{-# INLINE splitApBefore #-}
310−splitApBefore :: Monad m
162+splitApBefore :: MonadCatch m
311− => Int -> Stream m Int -> m (Either ParseError ())
163+ => Int -> SerialT m Int -> m ()
312splitApBefore value =
164splitApBefore value =
313− Stream.parse
165+ IP.parse
314− ( PR.dropWhile (<= (value `div` 2))
166+ ( PR.drainWhile (<= (value `div` 2))
315− *> PR.dropWhile (<= value)
167+ *> PR.drainWhile (<= value)
318{-# INLINE splitApAfter #-}
170{-# INLINE splitApAfter #-}
319−splitApAfter :: Monad m
171+splitApAfter :: MonadCatch m
320− => Int -> Stream m Int -> m (Either ParseError ())
172+ => Int -> SerialT m Int -> m ()
321splitApAfter value =
173splitApAfter value =
322− Stream.parse
174+ IP.parse
323− ( PR.dropWhile (<= (value `div` 2))
175+ ( PR.drainWhile (<= (value `div` 2))
324− <* PR.dropWhile (<= value)
176+ <* PR.drainWhile (<= value)
327−{-# INLINE splitWith2 #-}
179+{-# INLINE serialWith #-}
328−splitWith2 :: Monad m
180+serialWith :: MonadCatch m
329− => Int -> Stream m Int -> m (Either ParseError ((), ()))
181+ => Int -> SerialT m Int -> m ((), ())
330−splitWith2 value =
182+serialWith value =
331− Stream.parse
183+ IP.parse
332− (PR.splitWith (,)
184+ (PR.serialWith (,)
333− (PR.dropWhile (<= (value `div` 2)))
185+ (PR.drainWhile (<= (value `div` 2)))
334− (PR.dropWhile (<= value))
186+ (PR.drainWhile (<= value))
337{-# INLINE split_ #-}
189{-# INLINE split_ #-}
338−split_ :: Monad m
190+split_ :: MonadCatch m
339− => Int -> Stream m Int -> m (Either ParseError ())
191+ => Int -> SerialT m Int -> m ()
340split_ value =
192split_ value =
341− Stream.parse
193+ IP.parse
342 (PR.split_
194 (PR.split_
343− (PR.dropWhile (<= (value `div` 2)))
195+ (PR.drainWhile (<= (value `div` 2)))
344− (PR.dropWhile (<= value))
196+ (PR.drainWhile (<= value))
347−-- XXX dropWhile with applicative does not fuse
199+{-# INLINE sliceSepByP #-}
348−-- PR.dropWhile (<= (value * 1 `div` 4)) *> PR.die "alt"
200+sliceSepByP :: MonadCatch m
349−{-# INLINE takeWhileFail #-}
201+ => Int -> SerialT m Int -> m()
350−takeWhileFail :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
202+sliceSepByP value = IP.parse (PR.sliceSepByP (>= value) (PR.fromFold FL.drain))
351−takeWhileFail predicate (Fold fstep finitial _ ffinal) =
352− Parser step initial extract
358− return $ case res of
359− Fold.Partial s -> IPartial s
360− Fold.Done b -> IDone b
368− Fold.Partial s1 -> Partial 0 s1
369− Fold.Done b -> Done 0 b
370− else return $ Error "fail"
372− extract s = fmap (Done 0) (ffinal s)
376− => Int -> Stream m Int -> m (Either ParseError ())
380− (takeWhileFail (<= (value `div` 2)) Fold.drain)
381− (PR.dropWhile (<= value))
386− => Int -> Stream m Int -> m (Either ParseError ())
389− ( takeWhileFail (<= (value * 1 `div` 4)) Fold.drain
390− <|> takeWhileFail (<= (value * 2 `div` 4)) Fold.drain
391− <|> takeWhileFail (<= (value * 3 `div` 4)) Fold.drain
392− <|> PR.dropWhile (<= value)
397− => Int -> Stream m Int -> m (Either ParseError ())
400− ( takeWhileFail (<= (value * 1 `div` 8)) Fold.drain
401− <|> takeWhileFail (<= (value * 2 `div` 8)) Fold.drain
402− <|> takeWhileFail (<= (value * 3 `div` 8)) Fold.drain
403− <|> takeWhileFail (<= (value * 4 `div` 8)) Fold.drain
404− <|> takeWhileFail (<= (value * 5 `div` 8)) Fold.drain
405− <|> takeWhileFail (<= (value * 6 `div` 8)) Fold.drain
406− <|> takeWhileFail (<= (value * 7 `div` 8)) Fold.drain
407− <|> PR.dropWhile (<= value)
412− => Int -> Stream m Int -> m (Either ParseError ())
415− ( takeWhileFail (<= (value * 1 `div` 16)) Fold.drain
416− <|> takeWhileFail (<= (value * 2 `div` 16)) Fold.drain
417− <|> takeWhileFail (<= (value * 3 `div` 16)) Fold.drain
418− <|> takeWhileFail (<= (value * 4 `div` 16)) Fold.drain
419− <|> takeWhileFail (<= (value * 5 `div` 16)) Fold.drain
420− <|> takeWhileFail (<= (value * 6 `div` 16)) Fold.drain
421− <|> takeWhileFail (<= (value * 8 `div` 16)) Fold.drain
422− <|> takeWhileFail (<= (value * 9 `div` 16)) Fold.drain
423− <|> takeWhileFail (<= (value * 10 `div` 16)) Fold.drain
424− <|> takeWhileFail (<= (value * 11 `div` 16)) Fold.drain
425− <|> takeWhileFail (<= (value * 12 `div` 16)) Fold.drain
426− <|> takeWhileFail (<= (value * 13 `div` 16)) Fold.drain
427− <|> takeWhileFail (<= (value * 14 `div` 16)) Fold.drain
428− <|> takeWhileFail (<= (value * 15 `div` 16)) Fold.drain
429− <|> PR.dropWhile (<= value)
432−{-# INLINE altSmall #-}
434− => Int -> Stream m Int -> m ()
436− Stream.fold Fold.drain .
439− (PR.satisfy (>= value) *> PR.die "alt")
440− (PR.satisfy (<= value))
445− => Int -> Stream m Int -> m (Either ParseError ())
449− PR.dropWhile (<= (value `div` 2))
450− PR.dropWhile (<= value)
452−{-# INLINE monad4 #-}
454− => Int -> Stream m Int -> m (Either ParseError ())
457− PR.dropWhile (<= (value `div` 4))
458− PR.dropWhile (<= (value `div` 2))
459− PR.dropWhile (<= (value * 3 `div` 4))
460− PR.dropWhile (<= value)
462−{-# INLINE monad8 #-}
464− => Int -> Stream m Int -> m (Either ParseError ())
467− PR.dropWhile (<= (value * 1 `div` 8))
468− PR.dropWhile (<= (value * 2 `div` 8))
469− PR.dropWhile (<= (value * 3 `div` 8))
470− PR.dropWhile (<= (value * 4 `div` 8))
471− PR.dropWhile (<= (value * 5 `div` 8))
472− PR.dropWhile (<= (value * 6 `div` 8))
473− PR.dropWhile (<= (value * 7 `div` 8))
474− PR.dropWhile (<= value)
476−{-# INLINE monad16 #-}
478− => Int -> Stream m Int -> m (Either ParseError ())
481− PR.dropWhile (<= (value * 1 `div` 16))
482− PR.dropWhile (<= (value * 2 `div` 16))
483− PR.dropWhile (<= (value * 3 `div` 16))
484− PR.dropWhile (<= (value * 4 `div` 16))
485− PR.dropWhile (<= (value * 5 `div` 16))
486− PR.dropWhile (<= (value * 6 `div` 16))
487− PR.dropWhile (<= (value * 7 `div` 16))
488− PR.dropWhile (<= (value * 8 `div` 16))
489− PR.dropWhile (<= (value * 9 `div` 16))
490− PR.dropWhile (<= (value * 10 `div` 16))
491− PR.dropWhile (<= (value * 11 `div` 16))
492− PR.dropWhile (<= (value * 12 `div` 16))
493− PR.dropWhile (<= (value * 13 `div` 16))
494− PR.dropWhile (<= (value * 14 `div` 16))
495− PR.dropWhile (<= (value * 15 `div` 16))
496− PR.dropWhile (<= value)
498−{-# INLINE takeEndBy_ #-}
499−takeEndBy_ :: Monad m
500− => Int -> Stream m Int -> m (Either ParseError ())
501−takeEndBy_ value = Stream.parse (PR.takeEndBy_ (>= value) (PR.fromFold Fold.drain))
504{-# INLINE teeAllAny #-}
204{-# INLINE teeAllAny #-}
505−teeAllAny :: Monad m
205+teeAllAny :: MonadCatch m
506− => Int -> Stream m Int -> m ((), ())
206+ => Int -> SerialT m Int -> m ((), ())
507teeAllAny value =
207teeAllAny value =
508− Stream.parse
208+ IP.parse
509 (PR.teeWith (,)
209 (PR.teeWith (,)
510− (PR.dropWhile (<= value))
210+ (PR.drainWhile (<= value))
511− (PR.dropWhile (<= value))
211+ (PR.drainWhile (<= value))
514{-# INLINE teeFstAllAny #-}
214{-# INLINE teeFstAllAny #-}
515−teeFstAllAny :: Monad m
215+teeFstAllAny :: MonadCatch m
516− => Int -> Stream m Int -> m ((), ())
216+ => Int -> SerialT m Int -> m ((), ())
517teeFstAllAny value =
217teeFstAllAny value =
518− Stream.parse
218+ IP.parse
519 (PR.teeWithFst (,)
219 (PR.teeWithFst (,)
520− (PR.dropWhile (<= value))
220+ (PR.drainWhile (<= value))
521− (PR.dropWhile (<= value))
221+ (PR.drainWhile (<= value))
524{-# INLINE shortestAllAny #-}
224{-# INLINE shortestAllAny #-}
525−shortestAllAny :: Monad m
225+shortestAllAny :: MonadCatch m
526− => Int -> Stream m Int -> m (Either ParseError ())
226+ => Int -> SerialT m Int -> m ()
527shortestAllAny value =
227shortestAllAny value =
528− Stream.parse
228+ IP.parse
529 (PR.shortest
229 (PR.shortest
530− (PR.dropWhile (<= value))
230+ (PR.drainWhile (<= value))
531− (PR.dropWhile (<= value))
231+ (PR.drainWhile (<= value))
534{-# INLINE longestAllAny #-}
234{-# INLINE longestAllAny #-}
535−longestAllAny :: Monad m
235+longestAllAny :: MonadCatch m
536− => Int -> Stream m Int -> m (Either ParseError ())
236+ => Int -> SerialT m Int -> m ()
537longestAllAny value =
237longestAllAny value =
538− Stream.parse
238+ IP.parse
539 (PR.longest
239 (PR.longest
540− (PR.dropWhile (<= value))
240+ (PR.drainWhile (<= value))
541− (PR.dropWhile (<= value))
241+ (PR.drainWhile (<= value))
244+parseManyChunksOfSum :: Int -> Handle -> IO Int
245+parseManyChunksOfSum n inh =
248+ (PR.fromFold $ FL.take n FL.sum)
249+ (S.unfold Handle.read inh)
545-------------------------------------------------------------------------------
251-------------------------------------------------------------------------------
546−-- Spanning
252+-- Parsing with unfolds
547-------------------------------------------------------------------------------
253-------------------------------------------------------------------------------
549−{-# INLINE span #-}
255+{-# INLINE parseManyUnfoldArrays #-}
550−span :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))
256+parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()
551−span value = Stream.parse (PR.span (<= (value `div` 2)) Fold.drain Fold.drain)
257+parseManyUnfoldArrays count arrays = do
552−
258+ let src = Source.source (Just (Producer.OuterLoop arrays))
553−{-# INLINE spanBy #-}
554−spanBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))
556− Stream.parse (PR.spanBy (\_ i -> i <= (value `div` 2)) Fold.drain Fold.drain)
558−{-# INLINE spanByRolling #-}
559−spanByRolling :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))
560−spanByRolling value =
561− Stream.parse (PR.spanByRolling (\_ i -> i <= value `div` 2) Fold.drain Fold.drain)
563−parseManyChunksOfSum :: Int -> Handle -> IO Int
564−parseManyChunksOfSum n inh =
565− Stream.fold Fold.length
567− (PR.fromFold $ Fold.take n Fold.sum)
259+ let parser = PR.fromFold (FL.take count FL.drain)
568− (Stream.unfold Handle.reader inh)
260+ let readSrc =
262+ $ Producer.concat Producer.fromList Array.producer
264+ Producer.simplify (Source.parseMany parser readSrc)
265+ S.drain $ S.unfold streamParser src
570-------------------------------------------------------------------------------
267-------------------------------------------------------------------------------
571-- Parsers in which -fspec-constr-recursive=16 is problematic
268-- Parsers in which -fspec-constr-recursive=16 is problematic
@@ -576,129 +273,63 @@ parseManyChunksOfSum n inh =
576-- not have to rely on it.
273-- not have to rely on it.
578{-# INLINE lookAhead #-}
275{-# INLINE lookAhead #-}
579−lookAhead :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
276+lookAhead :: MonadCatch m => Int -> SerialT m Int -> m ()
580lookAhead value =
277lookAhead value =
581− Stream.parse (PR.lookAhead (PR.takeWhile (<= value) Fold.drain) $> ())
278+ IP.parse (PR.lookAhead (PR.takeWhile (<= value) FL.drain) $> ())
583−-- XXX The timing of this increased 3x after the stepify extract changes.
584−{-# INLINE sequenceA_ #-}
585−sequenceA_ :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
587− Stream.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))
589−-- quadratic complexity
590{-# INLINE sequenceA #-}
280{-# INLINE sequenceA #-}
591−sequenceA :: Monad m => Int -> Stream m Int -> m Int
281+sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int
592sequenceA value xs = do
282sequenceA value xs = do
593− x <- Stream.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs
283+ x <- IP.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs
594 return $ length x
284 return $ length x
596−-- quadratic complexity
286+{-# INLINE sequenceA_ #-}
287+sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()
289+ IP.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))
597{-# INLINE sequence #-}
291{-# INLINE sequence #-}
598−sequence :: Monad m => Int -> Stream m Int -> m Int
292+sequence :: MonadCatch m => Int -> SerialT m Int -> m Int
599sequence value xs = do
293sequence value xs = do
600− x <- Stream.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs
294+ x <- IP.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs
601 return $ length x
295 return $ length x
603{-# INLINE sequence_ #-}
297{-# INLINE sequence_ #-}
604−sequence_ :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
298+sequence_ :: MonadCatch m => Int -> SerialT m Int -> m ()
605−sequence_ value xs =
299+sequence_ value =
606− Stream.parse (foldr f (return ()) (replicate value (PR.takeBetween 0 1 Fold.drain))) xs
300+ IP.parse (F.sequence_ $ replicate value (PR.satisfy (> 0)))
611− f m k = m >>= (\_ -> k)
613−-- choice using the "Alternative" instance with direct style parser type has
614−-- quadratic performance complexity.
616{-# INLINE choiceAsum #-}
302{-# INLINE choiceAsum #-}
617−choiceAsum :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)
303+choiceAsum :: MonadCatch m => Int -> SerialT m Int -> m Int
618choiceAsum value =
304choiceAsum value =
619− Stream.parse (F.asum (replicate value (PR.satisfy (< 0)))
305+ IP.parse (asum (replicate value (PR.satisfy (< 0)))
620 AP.<|> PR.satisfy (> 0))
306 AP.<|> PR.satisfy (> 0))
623{-# INLINE choice #-}
308{-# INLINE choice #-}
624−choice :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)
309+choice :: MonadCatch m => Int -> SerialT m Int -> m Int
625choice value =
310choice value =
626− Stream.parse
311+ IP.parse
627 (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))
312 (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))
630−-------------------------------------------------------------------------------
631−-- Parsing with unfolds
632−-------------------------------------------------------------------------------
634−{-# INLINE parseManyUnfoldArrays #-}
635−parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()
636−parseManyUnfoldArrays count arrays = do
637− let src = Producer.source (Just (Producer.OuterLoop arrays))
638− let parser = PR.fromFold (Fold.take count Fold.drain)
641− $ Producer.concat Producer.fromList Array.producer
643− Producer.simplify (Producer.parseMany parser readSrc)
644− Stream.fold Fold.drain $ Stream.unfold streamParser src
646-------------------------------------------------------------------------------
314-------------------------------------------------------------------------------
647-- Stream transformation
315-- Stream transformation
648-------------------------------------------------------------------------------
316-------------------------------------------------------------------------------
650{-# INLINE parseMany #-}
318{-# INLINE parseMany #-}
651−parseMany :: Monad m => Int -> Stream m Int -> m ()
319+parseMany :: MonadCatch m => Int -> SerialT m Int -> m ()
652parseMany n =
320parseMany n =
653− Stream.fold Fold.drain
321+ S.drain
654− . fmap getSum
322+ . S.map getSum
655− . Stream.catRights . Stream.parseMany (PR.fromFold $ Fold.take n Fold.mconcat)
323+ . IP.parseMany (PR.fromFold $ FL.take n FL.mconcat)
656− . fmap Sum
324+ . S.map Sum
658−{-# INLINE parseManyGroupBy #-}
659−parseManyGroupBy :: Monad m => (Int -> Int -> Bool) -> Stream m Int -> m ()
660−parseManyGroupBy cmp =
661− Stream.fold Fold.drain . Stream.parseMany (PR.groupBy cmp Fold.drain)
663−{-# INLINE parseManyGroupsRolling #-}
664−parseManyGroupsRolling :: Monad m => Bool -> Stream m Int -> m ()
665−parseManyGroupsRolling b =
666− Stream.fold Fold.drain
667− . Stream.parseMany (PR.groupByRolling (\_ _ -> b) Fold.drain)
669−{-# INLINE parseManyGroupsRollingEither #-}
670−parseManyGroupsRollingEither :: Monad m =>
671− (Int -> Int -> Bool) -> Int -> m ()
672−parseManyGroupsRollingEither cmp value = do
673− sourceUnfoldrM value 1
674− & Stream.parseMany (PR.groupByRollingEither cmp Fold.drain Fold.drain)
675− & Stream.fold Fold.drain
677−{-# INLINE parseManyGroupsRollingEitherAlt #-}
678−parseManyGroupsRollingEitherAlt :: Monad m =>
679− (Int -> Int -> Bool) -> Int -> m ()
680−parseManyGroupsRollingEitherAlt cmp value = do
681− sourceUnfoldrM value 1
682− -- Make the input unsorted.
683− & fmap (\x -> if even x then x + 2 else x)
684− & Stream.parseMany (PR.groupByRollingEither cmp Fold.drain Fold.drain)
685− & Stream.fold Fold.drain
687{-# INLINE parseIterate #-}
326{-# INLINE parseIterate #-}
688−parseIterate :: Monad m => Int -> Stream m Int -> m ()
327+parseIterate :: MonadCatch m => Int -> SerialT m Int -> m ()
689parseIterate n =
328parseIterate n =
690− Stream.fold Fold.drain
329+ S.drain
691− . fmap getSum
330+ . S.map getSum
693− . Stream.parseIterate
694− (PR.fromFold . Fold.take n . Fold.sconcat)
331+ . IP.parseIterate (PR.fromFold . FL.take n . FL.sconcat) (Sum 0)
695− (Sum 0)
332+ . S.map Sum
698−{-# INLINE concatSequence #-}
699−concatSequence :: Monad m => Stream m Int -> m (Either ParseError ())
701− Stream.parse $ PR.sequence (Stream.repeat PR.one) Fold.drain
703-------------------------------------------------------------------------------
334-------------------------------------------------------------------------------
704-- Benchmarks
335-- Benchmarks
@@ -707,95 +338,42 @@ concatSequence =
707moduleName :: String
338moduleName :: String
708moduleName = "Data.Parser"
339moduleName = "Data.Parser"
710−instance NFData ParseError where
712− rnf (ParseError x) = rnf x
714o_1_space_serial :: Int -> [Benchmark]
341o_1_space_serial :: Int -> [Benchmark]
715o_1_space_serial value =
342o_1_space_serial value =
343+ [ benchIOSink value "next" $ next value
716− [ benchIOSink value "takeBetween" $ takeBetween value
344+ , benchIOSink value "takeBetween" $ takeBetween value
345+ , benchIOSink value "takeEQ" $ takeEQ value
717 , benchIOSink value "takeWhile" $ takeWhile value
346 , benchIOSink value "takeWhile" $ takeWhile value
718− , benchIOSink value "takeWhileP" $ takeWhileP value
719 , benchIOSink value "takeP" $ takeP value
347 , benchIOSink value "takeP" $ takeP value
720− , benchIOSink value "dropWhile" $ dropWhile value
348+ , benchIOSink value "drainWhile" $ drainWhile value
721− , benchIOSink value "takeStartBy" $ takeStartBy value
722− , benchIOSink value "takeEndBy_" $ takeEndBy_ value
349+ , benchIOSink value "sliceBeginWith" $ sliceBeginWith value
723 , benchIOSink value "groupBy" $ groupBy
350 , benchIOSink value "groupBy" $ groupBy
724 , benchIOSink value "groupByRolling" $ groupByRolling
351 , benchIOSink value "groupByRolling" $ groupByRolling
725 , benchIOSink value "wordBy" $ wordBy value
352 , benchIOSink value "wordBy" $ wordBy value
726− , benchIOSink value "sepBy (words)" sepByWords
353+ , benchIOSink value "splitAp" $ splitAp value
727− , benchIOSink value "sepByAll (words)" sepByAllWords
728− , benchIOSink value "sepBy1 (words)" sepByWords1
729− , benchIOSink value "deintercalate" $ deintercalate value
730− , benchIOSink value "deintercalate1" $ deintercalate1 value
731− , benchIOSink value "deintercalateAll" $ deintercalateAll value
732− -- Applicative and Monad
733− , benchIOSink value "splitAp2" $ splitAp2 value
734− , benchIOSink value "splitAp4" $ splitAp4 value
735− , benchIOSink value "splitAp8" $ splitAp8 value
736 , benchIOSink value "splitApBefore" $ splitApBefore value
354 , benchIOSink value "splitApBefore" $ splitApBefore value
737 , benchIOSink value "splitApAfter" $ splitApAfter value
355 , benchIOSink value "splitApAfter" $ splitApAfter value
738− , benchIOSink value "splitWith2" $ splitWith2 value
356+ , benchIOSink value "serialWith" $ serialWith value
739− , benchIOSink value "span" $ span value
740− , benchIOSink value "spanBy" $ spanBy value
741− , benchIOSink value "spanByRolling" $ spanByRolling value
742− , benchIOSink value "monad2" $ monad value
743− , benchIOSink value "monad4" $ monad4 value
744− , benchIOSink value "monad8" $ monad8 value
746− , benchIOSink value "alt2parseMany" $ altSmall value
747− , benchIOSink value "alt2" $ alt2 value
748− , benchIOSink value "alt4" $ alt4 value
749− , benchIOSink value "alt8" $ alt8 value
750− , benchIOSink value "alt16" $ alt16 value
357+ , benchIOSink value "sliceSepByP" $ sliceSepByP value
751 , benchIOSink value "many" many
358 , benchIOSink value "many" many
752 , benchIOSink value "many (wordBy even)" $ manyWordByEven
359 , benchIOSink value "many (wordBy even)" $ manyWordByEven
753 , benchIOSink value "some" some
360 , benchIOSink value "some" some
754 , benchIOSink value "manyTill" $ manyTill value
361 , benchIOSink value "manyTill" $ manyTill value
755− , benchIOSink value "parseMany" $ parseMany value
756− , benchIOSink value "parseMany (take 1)" (parseMany 1)
757− , benchIOSink value "parseMany (take all)" (parseMany value)
758− , benchIOSink value "parseMany (groupBy (<))" (parseManyGroupBy (<))
759− , benchIOSink value "parseMany (groupBy (==))" (parseManyGroupBy (==))
760− , benchIOSink value "parseMany groupRollingBy (bound groups)"
761− $ parseManyGroupsRolling False
762− , benchIOSink value "parseMany groupRollingBy (1 group)"
763− $ parseManyGroupsRolling True
764− , bench "parseMany groupRollingByEither (Left)"
765− $ nfIO $ parseManyGroupsRollingEitherLeft
766− , bench "parseMany groupRollingByEither (Right)"
767− $ nfIO $ parseManyGroupsRollingEitherRight
768− , bench "parseMany groupRollingByEither (Alternating)"
769− $ nfIO $ parseManyGroupsRollingEitherAlt1
770− , benchIOSink value "parseIterate (take 1)" (parseIterate 1)
771− , benchIOSink value "parseIterate (take all)" (parseIterate value)
772− , benchIOSink value "concatSequence" concatSequence
774 , benchIOSink value "tee" $ teeAllAny value
362 , benchIOSink value "tee" $ teeAllAny value
775 , benchIOSink value "teeFst" $ teeFstAllAny value
363 , benchIOSink value "teeFst" $ teeFstAllAny value
776 , benchIOSink value "shortest" $ shortestAllAny value
364 , benchIOSink value "shortest" $ shortestAllAny value
777 , benchIOSink value "longest" $ longestAllAny value
365 , benchIOSink value "longest" $ longestAllAny value
778− -}
366+ , benchIOSink value "parseMany (take 1)" (parseMany 1)
779− , benchIOSink value "streamEqBy" (streamEqBy value)
367+ , benchIOSink value "parseMany (take all)" (parseMany value)
368+ , benchIOSink value "parseIterate (take 1)" (parseIterate 1)
369+ , benchIOSink value "parseIterate (take all)" (parseIterate value)
784− {-# NOINLINE parseManyGroupsRollingEitherLeft #-}
785− parseManyGroupsRollingEitherLeft = parseManyGroupsRollingEither (<) value
787− {-# NOINLINE parseManyGroupsRollingEitherRight #-}
788− parseManyGroupsRollingEitherRight = parseManyGroupsRollingEither (>) value
790− {-# NOINLINE parseManyGroupsRollingEitherAlt1 #-}
791− parseManyGroupsRollingEitherAlt1 =
792− parseManyGroupsRollingEitherAlt (>) value
794o_1_space_filesystem :: BenchEnv -> [Benchmark]
372o_1_space_filesystem :: BenchEnv -> [Benchmark]
795o_1_space_filesystem env =
373o_1_space_filesystem env =
796− [ mkBench ("S.parseMany (Fold.take " ++ show (bigSize env) ++ " Fold.sum)") env
374+ [ mkBench ("S.parseMany (FL.take " ++ show (bigSize env) ++ " FL.sum)") env
797 $ \inh _ -> noinline parseManyChunksOfSum (bigSize env) inh
375 $ \inh _ -> noinline parseManyChunksOfSum (bigSize env) inh
798− , mkBench "S.parseMany (Fold.take 1 Fold.sum)" env
376+ , mkBench "S.parseMany (FL.take 1 FL.sum)" env
799 $ \inh _ -> inline parseManyChunksOfSum 1 inh
377 $ \inh _ -> inline parseManyChunksOfSum 1 inh
@@ -810,38 +388,26 @@ o_1_space_serial_unfold bound arrays =
810o_n_heap_serial :: Int -> [Benchmark]
388o_n_heap_serial :: Int -> [Benchmark]
811o_n_heap_serial value =
389o_n_heap_serial value =
813− benchIOSink value "takeEQ" $ takeEQ value
814− , benchIOSink value "takeGE" $ takeGE value
816 -- lookahead benchmark holds the entire input till end
391 -- lookahead benchmark holds the entire input till end
817− , benchIOSink value "lookAhead" $ lookAhead value
392+ benchIOSink value "lookAhead" $ lookAhead value
819− -- o-n-heap because of backtracking
394+ -- accumulates the results in a list
820− , benchIOSrc sourceEscapedFrames value "takeFramedByEsc_"
395+ , benchIOSink value "sequence" $ sequence value
821− $ takeFramedByEsc_ value
396+ , benchIOSink value "sequenceA" $ sequenceA value
398+ -- XXX why should this take O(n) heap, it discards the results?
399+ , benchIOSink value "sequence_" $ sequence_ value
400+ , benchIOSink value "sequenceA_" $ sequenceA_ value
823 -- non-linear time complexity (parserD)
401 -- non-linear time complexity (parserD)
824 , benchIOSink value "split_" $ split_ value
402 , benchIOSink value "split_" $ split_ value
825− -- XXX Takes lot of space when run on a long stream, why?
403+ -- XXX why O(n) heap?
826− , benchIOSink value "monad16" $ monad16 value
404+ , benchIOSink value "choice (asum)" $ choiceAsum value
405+ , benchIOSink value "choice" $ choice value
828 -- These show non-linear time complexity.
407 -- These show non-linear time complexity.
829 -- They accumulate the results in a list.
408 -- They accumulate the results in a list.
830− , benchIOSink value "sepBy1" sepBy1
831 , benchIOSink value "manyAlt" manyAlt
409 , benchIOSink value "manyAlt" manyAlt
832 , benchIOSink value "someAlt" someAlt
410 , benchIOSink value "someAlt" someAlt
833− , benchIOSink value "listEqBy" (listEqBy value)
836−-- accumulate results in a list in IO
837−o_n_space_serial :: Int -> [Benchmark]
838−o_n_space_serial value =
839− [ benchIOSink value "sequenceA/100" $ sequenceA (value `div` 100)
840− , benchIOSink value "sequenceA_/100" $ sequenceA_ (value `div` 100)
841− , benchIOSink value "sequence/100" $ sequence (value `div` 100)
842− , benchIOSink value "sequence_/100" $ sequence_ (value `div` 100)
843− , benchIOSink value "choice (asum)/100" $ choiceAsum (value `div` 100)
844− -- , benchIOSink value "choice/100" $ choice (value `div` 100)
847-------------------------------------------------------------------------------
413-------------------------------------------------------------------------------
@@ -850,13 +416,12 @@ o_n_space_serial value =
851main :: IO ()
417main :: IO ()
854 env <- mkHandleBenchEnv
419 env <- mkHandleBenchEnv
855 runWithCLIOptsEnv defaultStreamSize alloc (allBenchmarks env)
420 runWithCLIOptsEnv defaultStreamSize alloc (allBenchmarks env)
859− alloc value = Stream.fold Fold.toList $ Stream.chunksOf 100 $ sourceUnfoldrM value 0
424+ alloc value = IP.toList $ IP.arraysOf 100 $ sourceUnfoldrM value 0
861 allBenchmarks env arrays value =
426 allBenchmarks env arrays value =
862 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)
427 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)
@@ -866,22 +431,4 @@ main = do
866 , bgroup (o_1_space_prefix moduleName)
431 , bgroup (o_1_space_prefix moduleName)
867 (o_1_space_serial_unfold value arrays)
432 (o_1_space_serial_unfold value arrays)
868 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)
433 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)
869− , bgroup (o_n_space_prefix moduleName) (o_n_space_serial value)
872− -- Enable FUSION_CHECK macro at the beginning of the file
873− -- Enable one benchmark below, and run the benchmark
874− -- Check the .dump-simpl output
876− -- let input = sourceUnfoldrM value 1
877− -- manyTill value input
878− -- deintercalate value input
879− -- deintercalate1 value input
880− -- deintercalateAll value input
882− -- sepByAllWords input
884− -- sepByWords1 input
885− takeFramedByEsc_ value (sourceEscapedFrames value 1)