@@ -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,43 @@
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)
23+#if __GLASGOW_HASKELL__ >= 802
31import GHC.Magic (noinline)
24import GHC.Magic (noinline)
32import System.IO (Handle)
28import System.IO (Handle)
33import System.Random (randomRIO)
29import 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
30+import Prelude
39− (any, all, take, sequence, sequence_, sequenceA, takeWhile, dropWhile, span)
31+ 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
33import qualified Data.Traversable as TR
34+import qualified Data.Foldable as F
35+import qualified Control.Applicative as AP
44import qualified Streamly.FileSystem.Handle as Handle
36import qualified Streamly.FileSystem.Handle as Handle
45−import qualified Streamly.Internal.Data.Array as Array
37+import qualified Streamly.Prelude as S
38+import qualified Streamly.Internal.Data.Array.Foreign as Array
46−import qualified Streamly.Internal.Data.Fold as Fold
39+import qualified Streamly.Internal.Data.Fold as FL
47import qualified Streamly.Internal.Data.Parser as PR
40import qualified Streamly.Internal.Data.Parser as PR
48−import qualified Streamly.Data.Stream as Stream
41+import qualified Streamly.Internal.Data.Stream.IsStream as IP
49import qualified Streamly.Internal.Data.Producer as Producer
42import qualified Streamly.Internal.Data.Producer as Producer
50−import qualified Streamly.Internal.Data.Stream as Stream
43+import qualified Streamly.Internal.Data.Producer.Source as Source
52−import Test.Tasty.Bench hiding (env)
45+import Gauge hiding (env)
46+import Streamly.Prelude (SerialT)
53import Streamly.Benchmark.Common
47import Streamly.Benchmark.Common
54import Streamly.Benchmark.Common.Handle
48import Streamly.Benchmark.Common.Handle
@@ -60,59 +54,19 @@ import Streamly.Benchmark.Common.Handle
60-- XXX these can be moved to the common module
54-- XXX these can be moved to the common module
62{-# INLINE sourceUnfoldrM #-}
56{-# INLINE sourceUnfoldrM #-}
63−sourceUnfoldrM :: Monad m => Int -> Int -> Stream m Int
57+sourceUnfoldrM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
64−sourceUnfoldrM value n = Stream.unfoldrM step n
58+sourceUnfoldrM value n = S.unfoldrM step n
66 step cnt =
60 step cnt =
67 if cnt > n + value
61 if cnt > n + value
68 then return Nothing
62 then return Nothing
69 else return (Just (cnt, cnt + 1))
63 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.
65-- | Takes a fold method, and uses it with a default source.
112{-# INLINE benchIOSink #-}
66{-# INLINE benchIOSink #-}
113benchIOSink
67benchIOSink
114− :: NFData b
68+ :: (S.IsStream t, NFData b)
115− => Int -> String -> (Stream IO Int -> IO b) -> Benchmark
69+ => Int -> String -> (t IO Int -> IO b) -> Benchmark
116benchIOSink value name f =
70benchIOSink value name f =
117 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value
71 bench name $ nfIO $ randomRIO (1,1) >>= f . sourceUnfoldrM value
@@ -120,452 +74,199 @@ benchIOSink value name f =
120-- Parsers
74-- Parsers
121-------------------------------------------------------------------------------
75-------------------------------------------------------------------------------
78+next :: MonadCatch m => Int -> SerialT m Int -> m (Maybe Int)
79+next value = IP.parse p
84+ Just i -> if i >= value then pure m else p
85+ Nothing -> pure Nothing
123{-# INLINE takeBetween #-}
87{-# INLINE takeBetween #-}
124−takeBetween :: Monad m => Int -> Stream m a -> m (Either ParseError ())
88+takeBetween :: MonadCatch m => Int -> SerialT m a -> m ()
125−takeBetween value = Stream.parse (PR.takeBetween 0 value Fold.drain)
89+takeBetween value = IP.parse (PR.takeBetween 0 value FL.drain)
127{-# INLINE takeEQ #-}
91{-# INLINE takeEQ #-}
128−takeEQ :: Monad m => Int -> Stream m a -> m (Either ParseError ())
92+takeEQ :: MonadCatch m => Int -> SerialT m a -> m ()
129−takeEQ value = Stream.parse (PR.takeEQ value Fold.drain)
93+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 #-}
95+{-# INLINE drainWhile #-}
136−dropWhile :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
96+drainWhile :: MonadCatch m => Int -> SerialT m Int -> m ()
137−dropWhile value = Stream.parse (PR.dropWhile (<= value))
97+drainWhile value = IP.parse (PR.drainWhile (<= value))
139−{-# INLINE takeStartBy #-}
99+{-# INLINE sliceBeginWith #-}
140−takeStartBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
100+sliceBeginWith :: MonadCatch m => Int -> SerialT m Int -> m ()
141−takeStartBy value stream = do
101+sliceBeginWith value stream = do
102+ stream1 <- return . fromMaybe (S.fromPure (value + 1)) =<< S.tail stream
142− let stream2 = value `Stream.cons` stream
103+ let stream2 = value `S.cons` stream1
143− Stream.parse (PR.takeStartBy (== value) Fold.drain) stream2
104+ 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 #-}
106{-# INLINE takeWhile #-}
165−takeWhile :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
107+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))
108+takeWhile value = IP.parse (PR.takeWhile (<= value) FL.drain)
172{-# INLINE takeP #-}
110{-# INLINE takeP #-}
173−takeP :: Monad m => Int -> Stream m a -> m (Either ParseError ())
111+takeP :: MonadCatch m => Int -> SerialT m a -> m ()
174−takeP value = Stream.parse (PR.takeP value (PR.fromFold Fold.drain))
112+takeP value = IP.parse (PR.takeP value (PR.fromFold FL.drain))
176{-# INLINE groupBy #-}
114{-# INLINE groupBy #-}
177−groupBy :: Monad m => Stream m Int -> m (Either ParseError ())
115+groupBy :: MonadCatch m => SerialT m Int -> m ()
178−groupBy = Stream.parse (PR.groupBy (<=) Fold.drain)
116+groupBy = IP.parse (PR.groupBy (<=) FL.drain)
180{-# INLINE groupByRolling #-}
118{-# INLINE groupByRolling #-}
181−groupByRolling :: Monad m => Stream m Int -> m (Either ParseError ())
119+groupByRolling :: MonadCatch m => SerialT m Int -> m ()
182−groupByRolling = Stream.parse (PR.groupByRolling (<=) Fold.drain)
120+groupByRolling = IP.parse (PR.groupByRolling (<=) FL.drain)
184{-# INLINE wordBy #-}
122{-# INLINE wordBy #-}
185−wordBy :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
123+wordBy :: MonadCatch m => Int -> SerialT m Int -> m ()
186−wordBy value = Stream.parse (PR.wordBy (>= value) Fold.drain)
124+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 #-}
126{-# INLINE manyWordByEven #-}
243−manyWordByEven :: Monad m => Stream m Int -> m (Either ParseError ())
127+manyWordByEven :: MonadCatch m => SerialT m Int -> m ()
244−manyWordByEven = Stream.parse (PR.many (PR.wordBy even Fold.drain) Fold.drain)
128+manyWordByEven = IP.parse (PR.many (PR.wordBy (Prelude.even) FL.drain) FL.drain)
246{-# INLINE many #-}
130{-# INLINE many #-}
247−many :: Monad m => Stream m Int -> m (Either ParseError Int)
131+many :: MonadCatch m => SerialT m Int -> m Int
248−many = Stream.parse (PR.many (PR.satisfy (> 0)) Fold.length)
132+many = IP.parse (PR.many (PR.satisfy (> 0)) FL.length)
250{-# INLINE manyAlt #-}
134{-# INLINE manyAlt #-}
251−manyAlt :: Monad m => Stream m Int -> m Int
135+manyAlt :: MonadCatch m => SerialT m Int -> m Int
252manyAlt xs = do
136manyAlt xs = do
253− x <- Stream.parse (AP.many (PR.satisfy (> 0))) xs
137+ x <- IP.parse (AP.many (PR.satisfy (> 0))) xs
254 return $ Prelude.length x
138 return $ Prelude.length x
256{-# INLINE some #-}
140{-# INLINE some #-}
257−some :: Monad m => Stream m Int -> m (Either ParseError Int)
141+some :: MonadCatch m => SerialT m Int -> m Int
258−some = Stream.parse (PR.some (PR.satisfy (> 0)) Fold.length)
142+some = IP.parse (PR.some (PR.satisfy (> 0)) FL.length)
260{-# INLINE someAlt #-}
144{-# INLINE someAlt #-}
261−someAlt :: Monad m => Stream m Int -> m Int
145+someAlt :: MonadCatch m => SerialT m Int -> m Int
262someAlt xs = do
146someAlt xs = do
263− x <- Stream.parse (AP.some (PR.satisfy (> 0))) xs
147+ x <- IP.parse (AP.some (PR.satisfy (> 0))) xs
264 return $ Prelude.length x
148 return $ Prelude.length x
266{-# INLINE manyTill #-}
150{-# INLINE manyTill #-}
267−manyTill :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)
151+manyTill :: MonadCatch m => Int -> SerialT m Int -> m Int
268manyTill value =
152manyTill value =
269− Stream.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) Fold.length)
153+ IP.parse (PR.manyTill (PR.satisfy (> 0)) (PR.satisfy (== value)) FL.length)
271−{-# INLINE splitAp2 #-}
155+{-# INLINE splitAp #-}
272−splitAp2 :: Monad m
156+splitAp :: MonadCatch m
273− => Int -> Stream m Int -> m (Either ParseError ((), ()))
157+ => Int -> SerialT m Int -> m ((), ())
274−splitAp2 value =
158+splitAp value =
275− Stream.parse
159+ IP.parse
277− <$> PR.dropWhile (<= (value `div` 2))
161+ <$> PR.drainWhile (<= (value `div` 2))
278− <*> PR.dropWhile (<= value)
162+ <*> 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 #-}
165{-# INLINE splitApBefore #-}
310−splitApBefore :: Monad m
166+splitApBefore :: MonadCatch m
311− => Int -> Stream m Int -> m (Either ParseError ())
167+ => Int -> SerialT m Int -> m ()
312splitApBefore value =
168splitApBefore value =
313− Stream.parse
169+ IP.parse
314− ( PR.dropWhile (<= (value `div` 2))
170+ ( PR.drainWhile (<= (value `div` 2))
315− *> PR.dropWhile (<= value)
171+ *> PR.drainWhile (<= value)
318{-# INLINE splitApAfter #-}
174{-# INLINE splitApAfter #-}
319−splitApAfter :: Monad m
175+splitApAfter :: MonadCatch m
320− => Int -> Stream m Int -> m (Either ParseError ())
176+ => Int -> SerialT m Int -> m ()
321splitApAfter value =
177splitApAfter value =
322− Stream.parse
178+ IP.parse
323− ( PR.dropWhile (<= (value `div` 2))
179+ ( PR.drainWhile (<= (value `div` 2))
324− <* PR.dropWhile (<= value)
180+ <* PR.drainWhile (<= value)
327−{-# INLINE splitWith2 #-}
183+{-# INLINE serialWith #-}
328−splitWith2 :: Monad m
184+serialWith :: MonadCatch m
329− => Int -> Stream m Int -> m (Either ParseError ((), ()))
185+ => Int -> SerialT m Int -> m ((), ())
330−splitWith2 value =
186+serialWith value =
331− Stream.parse
187+ IP.parse
332− (PR.splitWith (,)
188+ (PR.serialWith (,)
333− (PR.dropWhile (<= (value `div` 2)))
189+ (PR.drainWhile (<= (value `div` 2)))
334− (PR.dropWhile (<= value))
190+ (PR.drainWhile (<= value))
337{-# INLINE split_ #-}
193{-# INLINE split_ #-}
338−split_ :: Monad m
194+split_ :: MonadCatch m
339− => Int -> Stream m Int -> m (Either ParseError ())
195+ => Int -> SerialT m Int -> m ()
340split_ value =
196split_ value =
341− Stream.parse
197+ IP.parse
342 (PR.split_
198 (PR.split_
343− (PR.dropWhile (<= (value `div` 2)))
199+ (PR.drainWhile (<= (value `div` 2)))
344− (PR.dropWhile (<= value))
200+ (PR.drainWhile (<= value))
347−-- XXX dropWhile with applicative does not fuse
203+{-# INLINE sliceSepByP #-}
348−-- PR.dropWhile (<= (value * 1 `div` 4)) *> PR.die "alt"
204+sliceSepByP :: MonadCatch m
349−{-# INLINE takeWhileFail #-}
205+ => Int -> SerialT m Int -> m()
350−takeWhileFail :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
206+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 #-}
208{-# INLINE teeAllAny #-}
505−teeAllAny :: Monad m
209+teeAllAny :: MonadCatch m
506− => Int -> Stream m Int -> m ((), ())
210+ => Int -> SerialT m Int -> m ((), ())
507teeAllAny value =
211teeAllAny value =
508− Stream.parse
212+ IP.parse
509 (PR.teeWith (,)
213 (PR.teeWith (,)
510− (PR.dropWhile (<= value))
214+ (PR.drainWhile (<= value))
511− (PR.dropWhile (<= value))
215+ (PR.drainWhile (<= value))
514{-# INLINE teeFstAllAny #-}
218{-# INLINE teeFstAllAny #-}
515−teeFstAllAny :: Monad m
219+teeFstAllAny :: MonadCatch m
516− => Int -> Stream m Int -> m ((), ())
220+ => Int -> SerialT m Int -> m ((), ())
517teeFstAllAny value =
221teeFstAllAny value =
518− Stream.parse
222+ IP.parse
519 (PR.teeWithFst (,)
223 (PR.teeWithFst (,)
520− (PR.dropWhile (<= value))
224+ (PR.drainWhile (<= value))
521− (PR.dropWhile (<= value))
225+ (PR.drainWhile (<= value))
524{-# INLINE shortestAllAny #-}
228{-# INLINE shortestAllAny #-}
525−shortestAllAny :: Monad m
229+shortestAllAny :: MonadCatch m
526− => Int -> Stream m Int -> m (Either ParseError ())
230+ => Int -> SerialT m Int -> m ()
527shortestAllAny value =
231shortestAllAny value =
528− Stream.parse
232+ IP.parse
529 (PR.shortest
233 (PR.shortest
530− (PR.dropWhile (<= value))
234+ (PR.drainWhile (<= value))
531− (PR.dropWhile (<= value))
235+ (PR.drainWhile (<= value))
534{-# INLINE longestAllAny #-}
238{-# INLINE longestAllAny #-}
535−longestAllAny :: Monad m
239+longestAllAny :: MonadCatch m
536− => Int -> Stream m Int -> m (Either ParseError ())
240+ => Int -> SerialT m Int -> m ()
537longestAllAny value =
241longestAllAny value =
538− Stream.parse
242+ IP.parse
539 (PR.longest
243 (PR.longest
540− (PR.dropWhile (<= value))
244+ (PR.drainWhile (<= value))
541− (PR.dropWhile (<= value))
245+ (PR.drainWhile (<= value))
248+parseManyChunksOfSum :: Int -> Handle -> IO Int
249+parseManyChunksOfSum n inh =
252+ (PR.fromFold $ FL.take n FL.sum)
253+ (S.unfold Handle.read inh)
545-------------------------------------------------------------------------------
255-------------------------------------------------------------------------------
546−-- Spanning
256+-- Parsing with unfolds
547-------------------------------------------------------------------------------
257-------------------------------------------------------------------------------
549−{-# INLINE span #-}
259+{-# INLINE parseManyUnfoldArrays #-}
550−span :: Monad m => Int -> Stream m Int -> m (Either ParseError ((), ()))
260+parseManyUnfoldArrays :: Int -> [Array.Array Int] -> IO ()
551−span value = Stream.parse (PR.span (<= (value `div` 2)) Fold.drain Fold.drain)
261+parseManyUnfoldArrays count arrays = do
552−
262+ 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)
263+ let parser = PR.fromFold (FL.take count FL.drain)
568− (Stream.unfold Handle.reader inh)
264+ let readSrc =
266+ $ Producer.concat Producer.fromList Array.producer
268+ Producer.simplify (Source.parseMany parser readSrc)
269+ S.drain $ S.unfold streamParser src
570-------------------------------------------------------------------------------
271-------------------------------------------------------------------------------
571-- Parsers in which -fspec-constr-recursive=16 is problematic
272-- Parsers in which -fspec-constr-recursive=16 is problematic
@@ -576,129 +277,63 @@ parseManyChunksOfSum n inh =
576-- not have to rely on it.
277-- not have to rely on it.
578{-# INLINE lookAhead #-}
279{-# INLINE lookAhead #-}
579−lookAhead :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
280+lookAhead :: MonadCatch m => Int -> SerialT m Int -> m ()
580lookAhead value =
281lookAhead value =
581− Stream.parse (PR.lookAhead (PR.takeWhile (<= value) Fold.drain) $> ())
282+ 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 #-}
284{-# INLINE sequenceA #-}
591−sequenceA :: Monad m => Int -> Stream m Int -> m Int
285+sequenceA :: MonadCatch m => Int -> SerialT m Int -> m Int
592sequenceA value xs = do
286sequenceA value xs = do
593− x <- Stream.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs
287+ x <- IP.parse (TR.sequenceA (replicate value (PR.satisfy (> 0)))) xs
594 return $ length x
288 return $ length x
596−-- quadratic complexity
290+{-# INLINE sequenceA_ #-}
291+sequenceA_ :: MonadCatch m => Int -> SerialT m Int -> m ()
293+ IP.parse (F.sequenceA_ $ replicate value (PR.satisfy (> 0)))
597{-# INLINE sequence #-}
295{-# INLINE sequence #-}
598−sequence :: Monad m => Int -> Stream m Int -> m Int
296+sequence :: MonadCatch m => Int -> SerialT m Int -> m Int
599sequence value xs = do
297sequence value xs = do
600− x <- Stream.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs
298+ x <- IP.parse (TR.sequence (replicate value (PR.satisfy (> 0)))) xs
601 return $ length x
299 return $ length x
603{-# INLINE sequence_ #-}
301{-# INLINE sequence_ #-}
604−sequence_ :: Monad m => Int -> Stream m Int -> m (Either ParseError ())
302+sequence_ :: MonadCatch m => Int -> SerialT m Int -> m ()
605−sequence_ value xs =
303+sequence_ value =
606− Stream.parse (foldr f (return ()) (replicate value (PR.takeBetween 0 1 Fold.drain))) xs
304+ 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 #-}
306{-# INLINE choiceAsum #-}
617−choiceAsum :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)
307+choiceAsum :: MonadCatch m => Int -> SerialT m Int -> m Int
618choiceAsum value =
308choiceAsum value =
619− Stream.parse (F.asum (replicate value (PR.satisfy (< 0)))
309+ IP.parse (asum (replicate value (PR.satisfy (< 0)))
620 AP.<|> PR.satisfy (> 0))
310 AP.<|> PR.satisfy (> 0))
623{-# INLINE choice #-}
312{-# INLINE choice #-}
624−choice :: Monad m => Int -> Stream m Int -> m (Either ParseError Int)
313+choice :: MonadCatch m => Int -> SerialT m Int -> m Int
625choice value =
314choice value =
626− Stream.parse
315+ IP.parse
627 (PR.choice (replicate value (PR.satisfy (< 0))) AP.<|> PR.satisfy (> 0))
316 (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-------------------------------------------------------------------------------
318-------------------------------------------------------------------------------
647-- Stream transformation
319-- Stream transformation
648-------------------------------------------------------------------------------
320-------------------------------------------------------------------------------
650{-# INLINE parseMany #-}
322{-# INLINE parseMany #-}
651−parseMany :: Monad m => Int -> Stream m Int -> m ()
323+parseMany :: MonadCatch m => Int -> SerialT m Int -> m ()
652parseMany n =
324parseMany n =
653− Stream.fold Fold.drain
325+ S.drain
654− . fmap getSum
326+ . S.map getSum
655− . Stream.catRights . Stream.parseMany (PR.fromFold $ Fold.take n Fold.mconcat)
327+ . IP.parseMany (PR.fromFold $ FL.take n FL.mconcat)
656− . fmap Sum
328+ . 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 #-}
330{-# INLINE parseIterate #-}
688−parseIterate :: Monad m => Int -> Stream m Int -> m ()
331+parseIterate :: MonadCatch m => Int -> SerialT m Int -> m ()
689parseIterate n =
332parseIterate n =
690− Stream.fold Fold.drain
333+ S.drain
691− . fmap getSum
334+ . S.map getSum
693− . Stream.parseIterate
694− (PR.fromFold . Fold.take n . Fold.sconcat)
335+ . IP.parseIterate (PR.fromFold . FL.take n . FL.sconcat) (Sum 0)
695− (Sum 0)
336+ . 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-------------------------------------------------------------------------------
338-------------------------------------------------------------------------------
704-- Benchmarks
339-- Benchmarks
@@ -707,95 +342,42 @@ concatSequence =
707moduleName :: String
342moduleName :: String
708moduleName = "Data.Parser"
343moduleName = "Data.Parser"
710−instance NFData ParseError where
712− rnf (ParseError x) = rnf x
714o_1_space_serial :: Int -> [Benchmark]
345o_1_space_serial :: Int -> [Benchmark]
715o_1_space_serial value =
346o_1_space_serial value =
347+ [ benchIOSink value "next" $ next value
716− [ benchIOSink value "takeBetween" $ takeBetween value
348+ , benchIOSink value "takeBetween" $ takeBetween value
349+ , benchIOSink value "takeEQ" $ takeEQ value
717 , benchIOSink value "takeWhile" $ takeWhile value
350 , benchIOSink value "takeWhile" $ takeWhile value
718− , benchIOSink value "takeWhileP" $ takeWhileP value
719 , benchIOSink value "takeP" $ takeP value
351 , benchIOSink value "takeP" $ takeP value
720− , benchIOSink value "dropWhile" $ dropWhile value
352+ , benchIOSink value "drainWhile" $ drainWhile value
721− , benchIOSink value "takeStartBy" $ takeStartBy value
722− , benchIOSink value "takeEndBy_" $ takeEndBy_ value
353+ , benchIOSink value "sliceBeginWith" $ sliceBeginWith value
723 , benchIOSink value "groupBy" $ groupBy
354 , benchIOSink value "groupBy" $ groupBy
724 , benchIOSink value "groupByRolling" $ groupByRolling
355 , benchIOSink value "groupByRolling" $ groupByRolling
725 , benchIOSink value "wordBy" $ wordBy value
356 , benchIOSink value "wordBy" $ wordBy value
726− , benchIOSink value "sepBy (words)" sepByWords
357+ , 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
358 , benchIOSink value "splitApBefore" $ splitApBefore value
737 , benchIOSink value "splitApAfter" $ splitApAfter value
359 , benchIOSink value "splitApAfter" $ splitApAfter value
738− , benchIOSink value "splitWith2" $ splitWith2 value
360+ , 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
361+ , benchIOSink value "sliceSepByP" $ sliceSepByP value
751 , benchIOSink value "many" many
362 , benchIOSink value "many" many
752 , benchIOSink value "many (wordBy even)" $ manyWordByEven
363 , benchIOSink value "many (wordBy even)" $ manyWordByEven
753 , benchIOSink value "some" some
364 , benchIOSink value "some" some
754 , benchIOSink value "manyTill" $ manyTill value
365 , 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
366 , benchIOSink value "tee" $ teeAllAny value
775 , benchIOSink value "teeFst" $ teeFstAllAny value
367 , benchIOSink value "teeFst" $ teeFstAllAny value
776 , benchIOSink value "shortest" $ shortestAllAny value
368 , benchIOSink value "shortest" $ shortestAllAny value
777 , benchIOSink value "longest" $ longestAllAny value
369 , benchIOSink value "longest" $ longestAllAny value
778− -}
370+ , benchIOSink value "parseMany (take 1)" (parseMany 1)
779− , benchIOSink value "streamEqBy" (streamEqBy value)
371+ , benchIOSink value "parseMany (take all)" (parseMany value)
372+ , benchIOSink value "parseIterate (take 1)" (parseIterate 1)
373+ , 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]
376o_1_space_filesystem :: BenchEnv -> [Benchmark]
795o_1_space_filesystem env =
377o_1_space_filesystem env =
796− [ mkBench ("S.parseMany (Fold.take " ++ show (bigSize env) ++ " Fold.sum)") env
378+ [ mkBench ("S.parseMany (FL.take " ++ show (bigSize env) ++ " FL.sum)") env
797 $ \inh _ -> noinline parseManyChunksOfSum (bigSize env) inh
379 $ \inh _ -> noinline parseManyChunksOfSum (bigSize env) inh
798− , mkBench "S.parseMany (Fold.take 1 Fold.sum)" env
380+ , mkBench "S.parseMany (FL.take 1 FL.sum)" env
799 $ \inh _ -> inline parseManyChunksOfSum 1 inh
381 $ \inh _ -> inline parseManyChunksOfSum 1 inh
@@ -810,38 +392,26 @@ o_1_space_serial_unfold bound arrays =
810o_n_heap_serial :: Int -> [Benchmark]
392o_n_heap_serial :: Int -> [Benchmark]
811o_n_heap_serial value =
393o_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
395 -- lookahead benchmark holds the entire input till end
817− , benchIOSink value "lookAhead" $ lookAhead value
396+ benchIOSink value "lookAhead" $ lookAhead value
819− -- o-n-heap because of backtracking
398+ -- accumulates the results in a list
820− , benchIOSrc sourceEscapedFrames value "takeFramedByEsc_"
399+ , benchIOSink value "sequence" $ sequence value
821− $ takeFramedByEsc_ value
400+ , benchIOSink value "sequenceA" $ sequenceA value
402+ -- XXX why should this take O(n) heap, it discards the results?
403+ , benchIOSink value "sequence_" $ sequence_ value
404+ , benchIOSink value "sequenceA_" $ sequenceA_ value
823 -- non-linear time complexity (parserD)
405 -- non-linear time complexity (parserD)
824 , benchIOSink value "split_" $ split_ value
406 , benchIOSink value "split_" $ split_ value
825− -- XXX Takes lot of space when run on a long stream, why?
407+ -- XXX why O(n) heap?
826− , benchIOSink value "monad16" $ monad16 value
408+ , benchIOSink value "choice (asum)" $ choiceAsum value
409+ , benchIOSink value "choice" $ choice value
828 -- These show non-linear time complexity.
411 -- These show non-linear time complexity.
829 -- They accumulate the results in a list.
412 -- They accumulate the results in a list.
830− , benchIOSink value "sepBy1" sepBy1
831 , benchIOSink value "manyAlt" manyAlt
413 , benchIOSink value "manyAlt" manyAlt
832 , benchIOSink value "someAlt" someAlt
414 , 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-------------------------------------------------------------------------------
417-------------------------------------------------------------------------------
@@ -850,13 +420,12 @@ o_n_space_serial value =
851main :: IO ()
421main :: IO ()
854 env <- mkHandleBenchEnv
423 env <- mkHandleBenchEnv
855 runWithCLIOptsEnv defaultStreamSize alloc (allBenchmarks env)
424 runWithCLIOptsEnv defaultStreamSize alloc (allBenchmarks env)
859− alloc value = Stream.fold Fold.toList $ Stream.chunksOf 100 $ sourceUnfoldrM value 0
428+ alloc value = IP.toList $ IP.arraysOf 100 $ sourceUnfoldrM value 0
861 allBenchmarks env arrays value =
430 allBenchmarks env arrays value =
862 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)
431 [ bgroup (o_1_space_prefix moduleName) (o_1_space_serial value)
@@ -866,22 +435,4 @@ main = do
866 , bgroup (o_1_space_prefix moduleName)
435 , bgroup (o_1_space_prefix moduleName)
867 (o_1_space_serial_unfold value arrays)
436 (o_1_space_serial_unfold value arrays)
868 , bgroup (o_n_heap_prefix moduleName) (o_n_heap_serial value)
437 , 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)