git.iko.soy/streamly
on master help sign in
Keep signature/pragma and definitions for each benchmark together
f2011dfadithyaov
benchmark/lib/Streamly/Benchmark/Prelude.hs+448−265
compare with master
unifiedsplit
@@ -287,56 +287,6 @@ currentTime value g _ = S.take value $ Internal.currentTime g
287runStream :: Monad m => Stream m a -> m ()
287runStream :: Monad m => Stream m a -> m ()
288runStream = S.drain
288runStream = S.drain
289
289
290−{-# INLINE toList #-}
291−toList :: Monad m => Stream m Int -> m [Int]
292−
293−{-# INLINE _head #-}
294−{-# INLINE last #-}
295−{-# INLINE maximum #-}
296−{-# INLINE minimum #-}
297−{-# INLINE find #-}
298−{-# INLINE findIndex #-}
299−{-# INLINE elemIndex #-}
300−{-# INLINE foldl1'Reduce #-}
301−_head, last, minimum, maximum, foldl1'Reduce
302− :: Monad m => Stream m Int -> m (Maybe Int)
303−
304−find, findIndex, elemIndex
305− :: Monad m => Int -> Stream m Int -> m (Maybe Int)
306−
307−{-# INLINE minimumBy #-}
308−{-# INLINE maximumBy #-}
309−minimumBy, maximumBy :: Monad m => Stream m Int -> m (Maybe Int)
310−
311−{-# INLINE foldl'Reduce #-}
312−{-# INLINE foldl'ReduceMap #-}
313−{-# INLINE foldlM'Reduce #-}
314−{-# INLINE foldrMReduce #-}
315−{-# INLINE length #-}
316−{-# INLINE sum #-}
317−{-# INLINE product #-}
318−foldl'Reduce, foldl'ReduceMap, foldlM'Reduce, foldrMReduce, length, sum, product
319− :: Monad m
320− => Stream m Int -> m Int
321−
322−{-# INLINE foldl'Build #-}
323−{-# INLINE foldlM'Build #-}
324−{-# INLINE foldrMBuild #-}
325−foldrMBuild, foldl'Build, foldlM'Build
326− :: Monad m
327− => Stream m Int -> m [Int]
328−
329−{-# INLINE all #-}
330−{-# INLINE any #-}
331−{-# INLINE and #-}
332−{-# INLINE or #-}
333−{-# INLINE _null #-}
334−{-# INLINE elem #-}
335−{-# INLINE notElem #-}
336−_null :: Monad m => Stream m Int -> m Bool
337−
338−elem, notElem, all, any, and, or :: Monad m => Int -> Stream m Int -> m Bool
339−
340{-# INLINE toNull #-}
290{-# INLINE toNull #-}
341toNull :: Monad m => (t m a -> S.SerialT m a) -> t m a -> m ()
291toNull :: Monad m => (t m a -> S.SerialT m a) -> t m a -> m ()
342toNull t = runStream . t
292toNull t = runStream . t
@@ -367,8 +317,10 @@ nullHeadTail s = do
367
317
368{-# INLINE mapM_ #-}
318{-# INLINE mapM_ #-}
369mapM_ :: Monad m => Stream m Int -> m ()
319mapM_ :: Monad m => Stream m Int -> m ()
370−mapM_ = S.mapM_ (\_ -> return ())
320+mapM_ = S.mapM_ (\_ -> return ())
371
321
322+{-# INLINE toList #-}
323+toList :: Monad m => Stream m Int -> m [Int]
372toList = S.toList
324toList = S.toList
373
325
374{-# INLINE toListRev #-}
326{-# INLINE toListRev #-}
@@ -377,41 +329,125 @@ toListRev = Internal.toListRev
377
329
378{-# INLINE foldrMElem #-}
330{-# INLINE foldrMElem #-}
379foldrMElem :: Monad m => Int -> Stream m Int -> m Bool
331foldrMElem :: Monad m => Int -> Stream m Int -> m Bool
332+foldrMElem e m =
333+ S.foldrM
334+ (\x xs ->
335+ if x == e
380−foldrMElem e m = S.foldrM (\x xs -> if x == e then return P.True else xs)
336+ then return P.True
337+ else xs)
381− (return P.False) m
338+ (return P.False)
339+ m
382
340
383{-# INLINE foldrMToStream #-}
341{-# INLINE foldrMToStream #-}
384foldrMToStream :: Monad m => Stream m Int -> m (Stream Identity Int)
342foldrMToStream :: Monad m => Stream m Int -> m (Stream Identity Int)
385−foldrMToStream = S.foldr S.cons S.nil
343+foldrMToStream = S.foldr S.cons S.nil
344+
345+{-# INLINE foldrMBuild #-}
346+foldrMBuild :: Monad m => Stream m Int -> m [Int]
347+foldrMBuild = S.foldrM (\x xs -> xs >>= return . (x :)) (return [])
386
348
387−foldrMBuild = S.foldrM (\x xs -> xs >>= return . (x :)) (return [])
349+{-# INLINE foldl'Build #-}
350+foldl'Build :: Monad m => Stream m Int -> m [Int]
388foldl'Build = S.foldl' (flip (:)) []
351foldl'Build = S.foldl' (flip (:)) []
352+
353+{-# INLINE foldlM'Build #-}
354+foldlM'Build :: Monad m => Stream m Int -> m [Int]
389foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) []
355foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) []
390
356
357+{-# INLINE foldrMReduce #-}
358+foldrMReduce :: Monad m => Stream m Int -> m Int
391foldrMReduce = S.foldrM (\x xs -> xs >>= return . (x +)) (return 0)
359foldrMReduce = S.foldrM (\x xs -> xs >>= return . (x +)) (return 0)
360+
361+{-# INLINE foldl'Reduce #-}
362+foldl'Reduce :: Monad m => Stream m Int -> m Int
392foldl'Reduce = S.foldl' (+) 0
363foldl'Reduce = S.foldl' (+) 0
364+
365+{-# INLINE foldl'ReduceMap #-}
366+foldl'ReduceMap :: Monad m => Stream m Int -> m Int
393−foldl'ReduceMap = P.fmap (+1) . S.foldl' (+) 0
367+foldl'ReduceMap = P.fmap (+ 1) . S.foldl' (+) 0
368+
369+{-# INLINE foldl1'Reduce #-}
370+foldl1'Reduce :: Monad m => Stream m Int -> m (Maybe Int)
394foldl1'Reduce = S.foldl1' (+)
371foldl1'Reduce = S.foldl1' (+)
372+
373+{-# INLINE foldlM'Reduce #-}
374+foldlM'Reduce :: Monad m => Stream m Int -> m Int
395foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) 0
375foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) 0
396
376
377+{-# INLINE last #-}
378+last :: Monad m => Stream m Int -> m (Maybe Int)
397−last = S.last
379+last = S.last
380+
381+{-# INLINE _null #-}
382+_null :: Monad m => Stream m Int -> m Bool
398−_null = S.null
383+_null = S.null
384+
385+{-# INLINE _head #-}
386+_head :: Monad m => Stream m Int -> m (Maybe Int)
399−_head = S.head
387+_head = S.head
388+
389+{-# INLINE elem #-}
390+elem :: Monad m => Int -> Stream m Int -> m Bool
400−elem value = S.elem (value + 1)
391+elem value = S.elem (value + 1)
392+
393+{-# INLINE notElem #-}
394+notElem :: Monad m => Int -> Stream m Int -> m Bool
401notElem value = S.notElem (value + 1)
395notElem value = S.notElem (value + 1)
396+
397+{-# INLINE length #-}
398+length :: Monad m => Stream m Int -> m Int
402length = S.length
399length = S.length
400+
401+{-# INLINE all #-}
402+all :: Monad m => Int -> Stream m Int -> m Bool
403−all value = S.all (<= (value + 1))
403+all value = S.all (<= (value + 1))
404+
405+{-# INLINE any #-}
406+any :: Monad m => Int -> Stream m Int -> m Bool
404−any value = S.any (> (value + 1))
407+any value = S.any (> (value + 1))
408+
409+{-# INLINE and #-}
410+and :: Monad m => Int -> Stream m Int -> m Bool
405−and value = S.and . S.map (<= (value + 1))
411+and value = S.and . S.map (<= (value + 1))
412+
413+{-# INLINE or #-}
414+or :: Monad m => Int -> Stream m Int -> m Bool
406−or value = S.or . S.map (> (value + 1))
415+or value = S.or . S.map (> (value + 1))
416+
417+{-# INLINE find #-}
418+find :: Monad m => Int -> Stream m Int -> m (Maybe Int)
407−find value = S.find (== (value + 1))
419+find value = S.find (== (value + 1))
420+
421+{-# INLINE findIndex #-}
422+findIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)
408findIndex value = S.findIndex (== (value + 1))
423findIndex value = S.findIndex (== (value + 1))
424+
425+{-# INLINE elemIndex #-}
426+elemIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)
409elemIndex value = S.elemIndex (value + 1)
427elemIndex value = S.elemIndex (value + 1)
428+
429+{-# INLINE maximum #-}
430+maximum :: Monad m => Stream m Int -> m (Maybe Int)
410maximum = S.maximum
431maximum = S.maximum
432+
433+{-# INLINE minimum #-}
434+minimum :: Monad m => Stream m Int -> m (Maybe Int)
411minimum = S.minimum
435minimum = S.minimum
436+
437+{-# INLINE sum #-}
438+sum :: Monad m => Stream m Int -> m Int
412−sum = S.sum
439+sum = S.sum
440+
441+{-# INLINE product #-}
442+product :: Monad m => Stream m Int -> m Int
413product = S.product
443product = S.product
444+
445+{-# INLINE minimumBy #-}
446+minimumBy :: Monad m => Stream m Int -> m (Maybe Int)
414minimumBy = S.minimumBy compare
447minimumBy = S.minimumBy compare
448+
449+{-# INLINE maximumBy #-}
450+maximumBy :: Monad m => Stream m Int -> m (Maybe Int)
415maximumBy = S.maximumBy compare
451maximumBy = S.maximumBy compare
416
452
417-------------------------------------------------------------------------------
453-------------------------------------------------------------------------------
@@ -423,9 +459,12 @@ transform :: Monad m => Stream m a -> m ()
423transform = runStream
459transform = runStream
424
460
425{-# INLINE composeN #-}
461{-# INLINE composeN #-}
426−composeN
462+composeN ::
427− :: MonadIO m
463+ MonadIO m
464+ => Int
428− => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()
465+ -> (Stream m Int -> Stream m Int)
466+ -> Stream m Int
467+ -> m ()
429composeN n f =
468composeN n f =
430 case n of
469 case n of
431 1 -> transform . f
470 1 -> transform . f
@@ -436,9 +475,12 @@ composeN n f =
436
475
437-- polymorphic stream version of composeN
476-- polymorphic stream version of composeN
438{-# INLINE composeN' #-}
477{-# INLINE composeN' #-}
439−composeN'
478+composeN' ::
440− :: (S.IsStream t, Monad m)
479+ (S.IsStream t, Monad m)
480+ => Int
441− => Int -> (t m Int -> Stream m Int) -> t m Int -> m ()
481+ -> (t m Int -> Stream m Int)
482+ -> t m Int
483+ -> m ()
442composeN' n f =
484composeN' n f =
443 case n of
485 case n of
444 1 -> transform . f
486 1 -> transform . f
@@ -448,71 +490,47 @@ composeN' n f =
448 _ -> undefined
490 _ -> undefined
449
491
450{-# INLINE scan #-}
492{-# INLINE scan #-}
493+scan :: MonadIO m => Int -> Stream m Int -> m ()
494+scan n = composeN n $ S.scanl' (+) 0
495+
451{-# INLINE scanl1' #-}
496{-# INLINE scanl1' #-}
452−{-# INLINE map #-}
453−{-# INLINE fmap #-}
454−{-# INLINE mapMaybe #-}
455−{-# INLINE filterEven #-}
456−{-# INLINE filterAllOut #-}
457−{-# INLINE filterAllIn #-}
458−{-# INLINE _takeOne #-}
459−{-# INLINE takeAll #-}
460−{-# INLINE takeWhileTrue #-}
461−{-# INLINE _takeWhileMTrue #-}
462−{-# INLINE dropOne #-}
463−{-# INLINE dropAll #-}
464−{-# INLINE dropWhileTrue #-}
465−{-# INLINE _dropWhileMTrue #-}
466−{-# INLINE dropWhileFalse #-}
467−{-# INLINE findIndices #-}
468−{-# INLINE elemIndices #-}
469−{-# INLINE insertBy #-}
470−{-# INLINE deleteBy #-}
471−{-# INLINE reverse #-}
472−{-# INLINE reverse' #-}
473−{-# INLINE foldrS #-}
474−{-# INLINE foldrSMap #-}
475−{-# INLINE foldrT #-}
476−{-# INLINE foldrTMap #-}
477−scan, scanl1', map, fmap, mapMaybe, filterEven,
478− _takeOne, dropOne,
479− reverse, reverse',
480− foldrS, foldrSMap, foldrT, foldrTMap
481− :: MonadIO m
482− => Int -> Stream m Int -> m ()
497+scanl1' :: MonadIO m => Int -> Stream m Int -> m ()
483−
498+scanl1' n = composeN n $ S.scanl1' (+)
484−filterAllOut,
485− filterAllIn, takeAll, takeWhileTrue, _takeWhileMTrue,
486− dropAll, dropWhileTrue, _dropWhileMTrue, dropWhileFalse,
487− findIndices, elemIndices, insertBy, deleteBy
488− :: MonadIO m
489− => Int -> Int -> Stream m Int -> m ()
490
499
491−{-# INLINE mapMaybeM #-}
500+{-# INLINE fmap #-}
492−{-# INLINE intersperse #-}
493−mapMaybeM :: S.MonadAsync m => Int -> Stream m Int -> m ()
501+fmap :: MonadIO m => Int -> Stream m Int -> m ()
494−intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()
502+fmap n = composeN n $ P.fmap (+ 1)
495
503
496−{-# INLINE mapM #-}
497−{-# INLINE map' #-}
498{-# INLINE fmap' #-}
504{-# INLINE fmap' #-}
505+fmap' ::
499−mapM, map' :: (S.IsStream t, S.MonadAsync m)
506+ (S.IsStream t, S.MonadAsync m, P.Functor (t m))
500− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
507+ => (t m Int -> S.SerialT m Int)
508+ -> Int
509+ -> t m Int
510+ -> m ()
511+fmap' t n = composeN' n $ t . P.fmap (+ 1)
501
512
502−fmap' :: (S.IsStream t, S.MonadAsync m, P.Functor (t m))
513+{-# INLINE map #-}
503− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
514+map :: MonadIO m => Int -> Stream m Int -> m ()
515+map n = composeN n $ S.map (+ 1)
504
516
505−{-# INLINE sequence #-}
517+{-# INLINE map' #-}
518+map' ::
506−sequence :: (S.IsStream t, S.MonadAsync m)
519+ (S.IsStream t, S.MonadAsync m)
507− => (t m Int -> S.SerialT m Int) -> t m (m Int) -> m ()
520+ => (t m Int -> S.SerialT m Int)
521+ -> Int
522+ -> t m Int
523+ -> m ()
524+map' t n = composeN' n $ t . S.map (+ 1)
508
525
509−scan n = composeN n $ S.scanl' (+) 0
526+{-# INLINE mapM #-}
510−scanl1' n = composeN n $ S.scanl1' (+)
527+mapM ::
511−fmap n = composeN n $ P.fmap (+1)
528+ (S.IsStream t, S.MonadAsync m)
512−fmap' t n = composeN' n $ t . P.fmap (+1)
529+ => (t m Int -> S.SerialT m Int)
513−map n = composeN n $ S.map (+1)
530+ -> Int
514−map' t n = composeN' n $ t . S.map (+1)
531+ -> t m Int
532+ -> m ()
515−mapM t n = composeN' n $ t . S.mapM return
533+mapM t n = composeN' n $ t . S.mapM return
516
534
517{-# INLINE tap #-}
535{-# INLINE tap #-}
518tap :: MonadIO m => Int -> Stream m Int -> m ()
536tap :: MonadIO m => Int -> Stream m Int -> m ()
@@ -528,7 +546,8 @@ tapRate n str = do
528pollCounts :: Int -> Stream IO Int -> IO ()
546pollCounts :: Int -> Stream IO Int -> IO ()
529pollCounts n str = do
547pollCounts n str = do
530 composeN n (Internal.pollCounts (P.const P.True) f FL.drain) str
548 composeN n (Internal.pollCounts (P.const P.True) f FL.drain) str
549+ where
531− where f = Internal.rollingMap (P.-) . Internal.delayPost 1
550+ f = Internal.rollingMap (P.-) . Internal.delayPost 1
532
551
533{-# INLINE tapAsyncS #-}
552{-# INLINE tapAsyncS #-}
534tapAsyncS :: S.MonadAsync m => Int -> Stream m Int -> m ()
553tapAsyncS :: S.MonadAsync m => Int -> Stream m Int -> m ()
@@ -538,34 +557,125 @@ tapAsyncS n = composeN n $ Par.tapAsync S.sum
538tapAsync :: S.MonadAsync m => Int -> Stream m Int -> m ()
557tapAsync :: S.MonadAsync m => Int -> Stream m Int -> m ()
539tapAsync n = composeN n $ Internal.tapAsync FL.sum
558tapAsync n = composeN n $ Internal.tapAsync FL.sum
540
559
560+{-# INLINE mapMaybe #-}
561+mapMaybe :: MonadIO m => Int -> Stream m Int -> m ()
562+mapMaybe n =
541−mapMaybe n = composeN n $ S.mapMaybe
563+ composeN n $
564+ S.mapMaybe
565+ (\x ->
566+ if P.odd x
542− (\x -> if P.odd x then Nothing else Just x)
567+ then Nothing
568+ else Just x)
569+
570+{-# INLINE mapMaybeM #-}
571+mapMaybeM :: S.MonadAsync m => Int -> Stream m Int -> m ()
543−mapMaybeM n = composeN n $ S.mapMaybeM
572+mapMaybeM n =
573+ composeN n $
574+ S.mapMaybeM
575+ (\x ->
576+ if P.odd x
544− (\x -> if P.odd x then return Nothing else return $ Just x)
577+ then return Nothing
578+ else return $ Just x)
579+
580+{-# INLINE sequence #-}
581+sequence ::
582+ (S.IsStream t, S.MonadAsync m)
583+ => (t m Int -> S.SerialT m Int)
584+ -> t m (m Int)
585+ -> m ()
545−sequence t = transform . t . S.sequence
586+sequence t = transform . t . S.sequence
587+
588+{-# INLINE filterEven #-}
589+filterEven :: MonadIO m => Int -> Stream m Int -> m ()
546−filterEven n = composeN n $ S.filter even
590+filterEven n = composeN n $ S.filter even
591+
592+{-# INLINE filterAllOut #-}
593+filterAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()
547−filterAllOut value n = composeN n $ S.filter (> (value + 1))
594+filterAllOut value n = composeN n $ S.filter (> (value + 1))
595+
596+{-# INLINE filterAllIn #-}
597+filterAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()
548−filterAllIn value n = composeN n $ S.filter (<= (value + 1))
598+filterAllIn value n = composeN n $ S.filter (<= (value + 1))
599+
600+{-# INLINE _takeOne #-}
601+_takeOne :: MonadIO m => Int -> Stream m Int -> m ()
549−_takeOne n = composeN n $ S.take 1
602+_takeOne n = composeN n $ S.take 1
603+
604+{-# INLINE takeAll #-}
605+takeAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()
550−takeAll value n = composeN n $ S.take (value + 1)
606+takeAll value n = composeN n $ S.take (value + 1)
607+
608+{-# INLINE takeWhileTrue #-}
609+takeWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
551takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))
610takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))
611+
612+{-# INLINE _takeWhileMTrue #-}
613+_takeWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
552_takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))
614_takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))
615+
616+{-# INLINE dropOne #-}
617+dropOne :: MonadIO m => Int -> Stream m Int -> m ()
553−dropOne n = composeN n $ S.drop 1
618+dropOne n = composeN n $ S.drop 1
619+
620+{-# INLINE dropAll #-}
621+dropAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()
554−dropAll value n = composeN n $ S.drop (value + 1)
622+dropAll value n = composeN n $ S.drop (value + 1)
623+
624+{-# INLINE dropWhileTrue #-}
625+dropWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
555−dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))
626+dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))
627+
628+{-# INLINE _dropWhileMTrue #-}
629+_dropWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
556_dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))
630_dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))
631+
632+{-# INLINE dropWhileFalse #-}
633+dropWhileFalse :: MonadIO m => Int -> Int -> Stream m Int -> m ()
557dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))
634dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))
635+
636+{-# INLINE findIndices #-}
637+findIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()
558−findIndices value n = composeN n $ S.findIndices (== (value + 1))
638+findIndices value n = composeN n $ S.findIndices (== (value + 1))
639+
640+{-# INLINE elemIndices #-}
641+elemIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()
559−elemIndices value n = composeN n $ S.elemIndices (value + 1)
642+elemIndices value n = composeN n $ S.elemIndices (value + 1)
643+
644+{-# INLINE intersperse #-}
645+intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()
560−intersperse value n = composeN n $ S.intersperse (value + 1)
646+intersperse value n = composeN n $ S.intersperse (value + 1)
647+
648+{-# INLINE insertBy #-}
649+insertBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()
561−insertBy value n = composeN n $ S.insertBy compare (value + 1)
650+insertBy value n = composeN n $ S.insertBy compare (value + 1)
651+
652+{-# INLINE deleteBy #-}
653+deleteBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()
562−deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)
654+deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)
655+
656+{-# INLINE reverse #-}
657+reverse :: MonadIO m => Int -> Stream m Int -> m ()
563−reverse n = composeN n $ S.reverse
658+reverse n = composeN n $ S.reverse
659+
660+{-# INLINE reverse' #-}
661+reverse' :: MonadIO m => Int -> Stream m Int -> m ()
564−reverse' n = composeN n $ Internal.reverse'
662+reverse' n = composeN n $ Internal.reverse'
663+
664+{-# INLINE foldrS #-}
665+foldrS :: MonadIO m => Int -> Stream m Int -> m ()
565−foldrS n = composeN n $ Internal.foldrS S.cons S.nil
666+foldrS n = composeN n $ Internal.foldrS S.cons S.nil
667+
668+{-# INLINE foldrSMap #-}
669+foldrSMap :: MonadIO m => Int -> Stream m Int -> m ()
566−foldrSMap n = composeN n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
670+foldrSMap n = composeN n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
671+
672+{-# INLINE foldrT #-}
673+foldrT :: MonadIO m => Int -> Stream m Int -> m ()
567−foldrT n = composeN n $ Internal.foldrT S.cons S.nil
674+foldrT n = composeN n $ Internal.foldrT S.cons S.nil
675+
676+{-# INLINE foldrTMap #-}
677+foldrTMap :: MonadIO m => Int -> Stream m Int -> m ()
568−foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
678+foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
569
679
570{-# INLINE takeByTime #-}
680{-# INLINE takeByTime #-}
571takeByTime :: NanoSecond64 -> Int -> Stream IO Int -> IO ()
681takeByTime :: NanoSecond64 -> Int -> Stream IO Int -> IO ()
@@ -591,121 +701,183 @@ inspect $ hasNoTypeClasses 'dropByTime
591-------------------------------------------------------------------------------
701-------------------------------------------------------------------------------
592
702
593{-# INLINE transformMapM #-}
703{-# INLINE transformMapM #-}
704+transformMapM ::
705+ (S.IsStream t, S.MonadAsync m)
706+ => (t m Int -> S.SerialT m Int)
707+ -> Int
708+ -> t m Int
709+ -> m ()
710+transformMapM t n = composeN' n $ t . Internal.transform (Pipe.mapM return)
711+
594{-# INLINE transformComposeMapM #-}
712{-# INLINE transformComposeMapM #-}
595−{-# INLINE transformTeeMapM #-}
713+transformComposeMapM ::
596−{-# INLINE transformZipMapM #-}
714+ (S.IsStream t, S.MonadAsync m)
715+ => (t m Int -> S.SerialT m Int)
716+ -> Int
717+ -> t m Int
718+ -> m ()
719+transformComposeMapM t n =
720+ composeN' n $
721+ t .
722+ Internal.transform
723+ (Pipe.mapM (\x -> return (x + 1)) `Pipe.compose`
724+ Pipe.mapM (\x -> return (x + 2)))
597
725
598−transformMapM, transformComposeMapM, transformTeeMapM,
726+{-# INLINE transformTeeMapM #-}
727+transformTeeMapM ::
599− transformZipMapM :: (S.IsStream t, S.MonadAsync m)
728+ (S.IsStream t, S.MonadAsync m)
600− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
729+ => (t m Int -> S.SerialT m Int)
730+ -> Int
731+ -> t m Int
732+ -> m ()
733+transformTeeMapM t n =
734+ composeN' n $
735+ t .
736+ Internal.transform
737+ (Pipe.mapM (\x -> return (x + 1)) `Pipe.tee`
738+ Pipe.mapM (\x -> return (x + 2)))
601
739
602−transformMapM t n = composeN' n $ t . Internal.transform (Pipe.mapM return)
740+{-# INLINE transformZipMapM #-}
603−transformComposeMapM t n = composeN' n $ t . Internal.transform
741+transformZipMapM ::
604− (Pipe.mapM (\x -> return (x + 1))
742+ (S.IsStream t, S.MonadAsync m)
605− `Pipe.compose` Pipe.mapM (\x -> return (x + 2)))
743+ => (t m Int -> S.SerialT m Int)
606−transformTeeMapM t n = composeN' n $ t . Internal.transform
744+ -> Int
607− (Pipe.mapM (\x -> return (x + 1))
745+ -> t m Int
608− `Pipe.tee` Pipe.mapM (\x -> return (x + 2)))
746+ -> m ()
609−transformZipMapM t n = composeN' n $ t . Internal.transform
747+transformZipMapM t n =
748+ composeN' n $
749+ t .
750+ Internal.transform
751+ (Pipe.zipWith
752+ (+)
610− (Pipe.zipWith (+) (Pipe.mapM (\x -> return (x + 1)))
753+ (Pipe.mapM (\x -> return (x + 1)))
611− (Pipe.mapM (\x -> return (x + 2))))
754+ (Pipe.mapM (\x -> return (x + 2))))
612
755
613-------------------------------------------------------------------------------
756-------------------------------------------------------------------------------
614-- Mixed Transformation
757-- Mixed Transformation
615-------------------------------------------------------------------------------
758-------------------------------------------------------------------------------
616
759
617{-# INLINE scanMap #-}
760{-# INLINE scanMap #-}
761+scanMap :: MonadIO m => Int -> Stream m Int -> m ()
762+scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0
763+
618{-# INLINE dropMap #-}
764{-# INLINE dropMap #-}
765+dropMap :: MonadIO m => Int -> Stream m Int -> m ()
766+dropMap n = composeN n $ S.map (subtract 1) . S.drop 1
767+
619{-# INLINE dropScan #-}
768{-# INLINE dropScan #-}
769+dropScan :: MonadIO m => Int -> Stream m Int -> m ()
770+dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
771+
620{-# INLINE takeDrop #-}
772{-# INLINE takeDrop #-}
773+takeDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()
774+takeDrop value n = composeN n $ S.drop 1 . S.take (value + 1)
775+
621{-# INLINE takeScan #-}
776{-# INLINE takeScan #-}
777+takeScan :: MonadIO m => Int -> Int -> Stream m Int -> m ()
778+takeScan value n = composeN n $ S.scanl' (+) 0 . S.take (value + 1)
779+
622{-# INLINE takeMap #-}
780{-# INLINE takeMap #-}
781+takeMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()
782+takeMap value n = composeN n $ S.map (subtract 1) . S.take (value + 1)
783+
623{-# INLINE filterDrop #-}
784{-# INLINE filterDrop #-}
624−{-# INLINE filterTake #-}
625−{-# INLINE filterScan #-}
626−{-# INLINE filterScanl1 #-}
627−{-# INLINE filterMap #-}
628−scanMap, dropMap, dropScan,
629− filterScan, filterScanl1
630− :: MonadIO m => Int -> Stream m Int -> m ()
631−
632−takeDrop, takeScan, takeMap, filterDrop,
633− filterTake, filterMap
634− :: MonadIO m => Int -> Int -> Stream m Int -> m ()
785+filterDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()
635−
636−scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0
637−dropMap n = composeN n $ S.map (subtract 1) . S.drop 1
638−dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
639−takeDrop value n = composeN n $ S.drop 1 . S.take (value + 1)
640−takeScan value n = composeN n $ S.scanl' (+) 0 . S.take (value + 1)
641−takeMap value n = composeN n $ S.map (subtract 1) . S.take (value + 1)
642filterDrop value n = composeN n $ S.drop 1 . S.filter (<= (value + 1))
786filterDrop value n = composeN n $ S.drop 1 . S.filter (<= (value + 1))
787+
788+{-# INLINE filterTake #-}
789+filterTake :: MonadIO m => Int -> Int -> Stream m Int -> m ()
643filterTake value n = composeN n $ S.take (value + 1) . S.filter (<= (value + 1))
790filterTake value n = composeN n $ S.take (value + 1) . S.filter (<= (value + 1))
791+
792+{-# INLINE filterScan #-}
793+filterScan :: MonadIO m => Int -> Stream m Int -> m ()
644filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
794filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
795+
796+{-# INLINE filterScanl1 #-}
797+filterScanl1 :: MonadIO m => Int -> Stream m Int -> m ()
645filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)
798filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)
799+
800+{-# INLINE filterMap #-}
801+filterMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()
646−filterMap value n = composeN n $ S.map (subtract 1) . S.filter (<= (value + 1))
802+filterMap value n = composeN n $ S.map (subtract 1) . S.filter (<= (value + 1))
647
803
648-------------------------------------------------------------------------------
804-------------------------------------------------------------------------------
649-- Scan and fold
805-- Scan and fold
650-------------------------------------------------------------------------------
806-------------------------------------------------------------------------------
651
807
808+data Pair a b =
809+ Pair !a !b
652−data Pair a b = Pair !a !b deriving (Generic, NFData)
810+ deriving (Generic, NFData)
653
811
654{-# INLINE sumProductFold #-}
812{-# INLINE sumProductFold #-}
655sumProductFold :: Monad m => Stream m Int -> m (Int, Int)
813sumProductFold :: Monad m => Stream m Int -> m (Int, Int)
656−sumProductFold = S.foldl' (\(s,p) x -> (s + x, p P.* x)) (0,1)
814+sumProductFold = S.foldl' (\(s, p) x -> (s + x, p P.* x)) (0, 1)
657
815
658{-# INLINE sumProductScan #-}
816{-# INLINE sumProductScan #-}
659sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)
817sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)
818+sumProductScan =
660−sumProductScan = S.foldl' (\(Pair _ p) (s0,x) -> Pair s0 (p P.* x)) (Pair 0 1)
819+ S.foldl' (\(Pair _ p) (s0, x) -> Pair s0 (p P.* x)) (Pair 0 1) .
661− . S.scanl' (\(s,_) x -> (s + x,x)) (0,0)
820+ S.scanl' (\(s, _) x -> (s + x, x)) (0, 0)
662
821
663-------------------------------------------------------------------------------
822-------------------------------------------------------------------------------
664-- Iteration
823-- Iteration
665-------------------------------------------------------------------------------
824-------------------------------------------------------------------------------
666
825
667−iterStreamLen, maxIters :: Int
826+{-# INLINE iterStreamLen #-}
827+iterStreamLen :: Int
668iterStreamLen = 10
828iterStreamLen = 10
829+
830+{-# INLINE maxIters #-}
831+maxIters :: Int
669maxIters = 10000
832maxIters = 10000
670
833
671{-# INLINE iterateSource #-}
834{-# INLINE iterateSource #-}
672−iterateSource
835+iterateSource ::
673− :: S.MonadAsync m
836+ S.MonadAsync m
674− => (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
837+ => (Stream m Int -> Stream m Int)
838+ -> Int
839+ -> Int
840+ -> Stream m Int
675iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)
841iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)
676− where
842+ where
677− f (0 :: Int) m = g m
843+ f (0 :: Int) m = g m
678− f x m = g (f (x P.- 1) m)
844+ f x m = g (f (x P.- 1) m)
679
845
680−{-# INLINE iterateMapM #-}
846+-- this is quadratic
681{-# INLINE iterateScan #-}
847{-# INLINE iterateScan #-}
848+iterateScan :: S.MonadAsync m => Int -> Stream m Int
849+iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)
850+
851+-- this is quadratic
682{-# INLINE iterateScanl1 #-}
852{-# INLINE iterateScanl1 #-}
853+iterateScanl1 :: S.MonadAsync m => Int -> Stream m Int
854+iterateScanl1 = iterateSource (S.scanl1' (+)) (maxIters `div` 10)
855+
856+{-# INLINE iterateMapM #-}
857+iterateMapM :: S.MonadAsync m => Int -> Stream m Int
858+iterateMapM = iterateSource (S.mapM return) maxIters
859+
683{-# INLINE iterateFilterEven #-}
860{-# INLINE iterateFilterEven #-}
861+iterateFilterEven :: S.MonadAsync m => Int -> Stream m Int
862+iterateFilterEven = iterateSource (S.filter even) maxIters
863+
684{-# INLINE iterateTakeAll #-}
864{-# INLINE iterateTakeAll #-}
685−{-# INLINE iterateDropOne #-}
686−{-# INLINE iterateDropWhileFalse #-}
687−{-# INLINE iterateDropWhileTrue #-}
688−iterateMapM, iterateScan, iterateScanl1, iterateFilterEven,
689− iterateDropOne
690− :: S.MonadAsync m
691− => Int -> Stream m Int
865+iterateTakeAll :: S.MonadAsync m => Int -> Int -> Stream m Int
866+iterateTakeAll value = iterateSource (S.take (value + 1)) maxIters
692
867
693−iterateTakeAll,
868+{-# INLINE iterateDropOne #-}
694− iterateDropWhileFalse, iterateDropWhileTrue
695− :: S.MonadAsync m
869+iterateDropOne :: S.MonadAsync m => Int -> Stream m Int
696− => Int -> Int -> Stream m Int
870+iterateDropOne = iterateSource (S.drop 1) maxIters
697
871
698−-- this is quadratic
872+{-# INLINE iterateDropWhileFalse #-}
699−iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)
873+iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Stream m Int
700−-- so is this
874+iterateDropWhileFalse value =
701−iterateScanl1 = iterateSource (S.scanl1' (+)) (maxIters `div` 10)
875+ iterateSource (S.dropWhile (> (value + 1))) maxIters
702
876
703−iterateMapM = iterateSource (S.mapM return) maxIters
877+{-# INLINE iterateDropWhileTrue #-}
704−iterateFilterEven = iterateSource (S.filter even) maxIters
878+iterateDropWhileTrue :: S.MonadAsync m => Int -> Int -> Stream m Int
705−iterateTakeAll value = iterateSource (S.take (value + 1)) maxIters
879+iterateDropWhileTrue value =
706−iterateDropOne = iterateSource (S.drop 1) maxIters
707−iterateDropWhileFalse value = iterateSource (S.dropWhile (> (value + 1))) maxIters
708−iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1))) maxIters
880+ iterateSource (S.dropWhile (<= (value + 1))) maxIters
709
881
710-------------------------------------------------------------------------------
882-------------------------------------------------------------------------------
711-- Combining streams
883-- Combining streams
@@ -718,34 +890,35 @@ iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1))) maxI
718{-# INLINE serial2 #-}
890{-# INLINE serial2 #-}
719serial2 :: Int -> Int -> IO ()
891serial2 :: Int -> Int -> IO ()
720serial2 count n =
892serial2 count n =
721− S.drain $ S.serial
722− (sourceUnfoldrMN count n)
723− (sourceUnfoldrMN count (n + 1))
893+ S.drain $ S.serial (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))
724
894
725{-# INLINE serial4 #-}
895{-# INLINE serial4 #-}
726serial4 :: Int -> Int -> IO ()
896serial4 :: Int -> Int -> IO ()
727serial4 count n =
897serial4 count n =
898+ S.drain $
728− S.drain $ S.serial
899+ S.serial
729− ((S.serial (sourceUnfoldrMN count n)
900+ ((S.serial (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))))
730− (sourceUnfoldrMN count (n + 1))))
901+ ((S.serial
731− ((S.serial (sourceUnfoldrMN count (n+2))
902+ (sourceUnfoldrMN count (n + 2))
732− (sourceUnfoldrMN count (n + 3))))
903+ (sourceUnfoldrMN count (n + 3))))
733
904
734{-# INLINE append2 #-}
905{-# INLINE append2 #-}
735append2 :: Int -> Int -> IO ()
906append2 :: Int -> Int -> IO ()
736append2 count n =
907append2 count n =
737− S.drain $ Internal.append
908+ S.drain $
738− (sourceUnfoldrMN count n)
739− (sourceUnfoldrMN count (n + 1))
909+ Internal.append (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))
740
910
741{-# INLINE append4 #-}
911{-# INLINE append4 #-}
742append4 :: Int -> Int -> IO ()
912append4 :: Int -> Int -> IO ()
743append4 count n =
913append4 count n =
914+ S.drain $
744− S.drain $ Internal.append
915+ Internal.append
916+ ((Internal.append
745− ((Internal.append (sourceUnfoldrMN count n)
917+ (sourceUnfoldrMN count n)
746− (sourceUnfoldrMN count (n + 1))))
918+ (sourceUnfoldrMN count (n + 1))))
919+ ((Internal.append
747− ((Internal.append (sourceUnfoldrMN count (n+2))
920+ (sourceUnfoldrMN count (n + 2))
748− (sourceUnfoldrMN count (n + 3))))
921+ (sourceUnfoldrMN count (n + 3))))
749
922
750#ifdef INSPECTION
923#ifdef INSPECTION
751inspect $ hasNoTypeClasses 'append2
924inspect $ hasNoTypeClasses 'append2
@@ -759,15 +932,19 @@ inspect $ 'append2 `hasNoType` ''D.AppendState
759
932
760{-# INLINE wSerial2 #-}
933{-# INLINE wSerial2 #-}
761wSerial2 :: Int -> Int -> IO ()
934wSerial2 :: Int -> Int -> IO ()
762−wSerial2 value n = S.drain $ S.wSerial
935+wSerial2 value n =
936+ S.drain $
937+ S.wSerial
763− (sourceUnfoldrMN (value `div` 2) n)
938+ (sourceUnfoldrMN (value `div` 2) n)
764− (sourceUnfoldrMN (value `div` 2) (n + 1))
939+ (sourceUnfoldrMN (value `div` 2) (n + 1))
765
940
766{-# INLINE interleave2 #-}
941{-# INLINE interleave2 #-}
767interleave2 :: Int -> Int -> IO ()
942interleave2 :: Int -> Int -> IO ()
943+interleave2 value n =
944+ S.drain $
768−interleave2 value n = S.drain $ Internal.interleave
945+ Internal.interleave
769− (sourceUnfoldrMN (value `div` 2) n)
946+ (sourceUnfoldrMN (value `div` 2) n)
770− (sourceUnfoldrMN (value `div` 2) (n + 1))
947+ (sourceUnfoldrMN (value `div` 2) (n + 1))
771
948
772#ifdef INSPECTION
949#ifdef INSPECTION
773inspect $ hasNoTypeClasses 'interleave2
950inspect $ hasNoTypeClasses 'interleave2
@@ -777,9 +954,11 @@ inspect $ 'interleave2 `hasNoType` ''D.InterleaveState
777
954
778{-# INLINE roundRobin2 #-}
955{-# INLINE roundRobin2 #-}
779roundRobin2 :: Int -> Int -> IO ()
956roundRobin2 :: Int -> Int -> IO ()
957+roundRobin2 value n =
958+ S.drain $
780−roundRobin2 value n = S.drain $ Internal.roundrobin
959+ Internal.roundrobin
781− (sourceUnfoldrMN (value `div` 2) n)
960+ (sourceUnfoldrMN (value `div` 2) n)
782− (sourceUnfoldrMN (value `div` 2) (n + 1))
961+ (sourceUnfoldrMN (value `div` 2) (n + 1))
783
962
784#ifdef INSPECTION
963#ifdef INSPECTION
785inspect $ hasNoTypeClasses 'roundRobin2
964inspect $ hasNoTypeClasses 'roundRobin2
@@ -794,7 +973,9 @@ inspect $ 'roundRobin2 `hasNoType` ''D.InterleaveState
794{-# INLINE mergeBy #-}
973{-# INLINE mergeBy #-}
795mergeBy :: Int -> Int -> IO ()
974mergeBy :: Int -> Int -> IO ()
796mergeBy count n =
975mergeBy count n =
976+ S.drain $
797− S.drain $ S.mergeBy P.compare
977+ S.mergeBy
978+ P.compare
798 (sourceUnfoldrMN count n)
979 (sourceUnfoldrMN count n)
799 (sourceUnfoldrMN count (n + 1))
980 (sourceUnfoldrMN count (n + 1))
800
981
@@ -811,9 +992,8 @@ inspect $ 'mergeBy `hasNoType` ''D.Step
811{-# INLINE zip #-}
992{-# INLINE zip #-}
812zip :: Int -> Int -> IO ()
993zip :: Int -> Int -> IO ()
813zip count n =
994zip count n =
814− S.drain $ S.zipWith (,)
995+ S.drain $
815− (sourceUnfoldrMN count n)
816− (sourceUnfoldrMN count (n + 1))
996+ S.zipWith (,) (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))
817
997
818#ifdef INSPECTION
998#ifdef INSPECTION
819inspect $ hasNoTypeClasses 'zip
999inspect $ hasNoTypeClasses 'zip
@@ -824,7 +1004,9 @@ inspect $ 'zip `hasNoType` ''D.Step
824{-# INLINE zipM #-}
1004{-# INLINE zipM #-}
825zipM :: Int -> Int -> IO ()
1005zipM :: Int -> Int -> IO ()
826zipM count n =
1006zipM count n =
1007+ S.drain $
1008+ S.zipWithM
827− S.drain $ S.zipWithM (curry return)
1009+ (curry return)
828 (sourceUnfoldrMN count n)
1010 (sourceUnfoldrMN count n)
829 (sourceUnfoldrMN count (n + 1))
1011 (sourceUnfoldrMN count (n + 1))
830
1012
@@ -837,35 +1019,35 @@ inspect $ 'zipM `hasNoType` ''D.Step
837{-# INLINE zipAsync #-}
1019{-# INLINE zipAsync #-}
838zipAsync :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
1020zipAsync :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
839zipAsync count n = do
1021zipAsync count n = do
840− S.zipAsyncWith (,)
841− (sourceUnfoldrMN count n)
842− (sourceUnfoldrMN count (n + 1))
1022+ S.zipAsyncWith (,) (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))
843
1023
844{-# INLINE zipAsyncM #-}
1024{-# INLINE zipAsyncM #-}
845zipAsyncM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
1025zipAsyncM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
846zipAsyncM count n = do
1026zipAsyncM count n = do
847− S.zipAsyncWithM (curry return)
1027+ S.zipAsyncWithM
1028+ (curry return)
848 (sourceUnfoldrMN count n)
1029 (sourceUnfoldrMN count n)
849 (sourceUnfoldrMN count (n + 1))
1030 (sourceUnfoldrMN count (n + 1))
850
1031
851{-# INLINE zipAsyncAp #-}
1032{-# INLINE zipAsyncAp #-}
852zipAsyncAp :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
1033zipAsyncAp :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
853−zipAsyncAp count n = do
1034+zipAsyncAp count n = do
854− S.zipAsyncly $ (,)
1035+ S.zipAsyncly $
855− <$> (sourceUnfoldrMN count n)
856− <*> (sourceUnfoldrMN count (n + 1))
1036+ (,) <$> (sourceUnfoldrMN count n) <*> (sourceUnfoldrMN count (n + 1))
857
1037
858{-# INLINE mergeAsyncByM #-}
1038{-# INLINE mergeAsyncByM #-}
859mergeAsyncByM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
1039mergeAsyncByM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
860mergeAsyncByM count n = do
1040mergeAsyncByM count n = do
1041+ S.mergeAsyncByM
861− S.mergeAsyncByM (\a b -> return (a `compare` b))
1042+ (\a b -> return (a `compare` b))
862 (sourceUnfoldrMN count n)
1043 (sourceUnfoldrMN count n)
863 (sourceUnfoldrMN count (n + 1))
1044 (sourceUnfoldrMN count (n + 1))
864
1045
865{-# INLINE mergeAsyncBy #-}
1046{-# INLINE mergeAsyncBy #-}
866mergeAsyncBy :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
1047mergeAsyncBy :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
867mergeAsyncBy count n = do
1048mergeAsyncBy count n = do
868− S.mergeAsyncBy compare
1049+ S.mergeAsyncBy
1050+ compare
869 (sourceUnfoldrMN count n)
1051 (sourceUnfoldrMN count n)
870 (sourceUnfoldrMN count (n + 1))
1052 (sourceUnfoldrMN count (n + 1))
871
1053
@@ -874,10 +1056,11 @@ mergeAsyncBy count n = do
874-------------------------------------------------------------------------------
1056-------------------------------------------------------------------------------
875
1057
876{-# INLINE isPrefixOf #-}
1058{-# INLINE isPrefixOf #-}
877−{-# INLINE isSubsequenceOf #-}
878−isPrefixOf, isSubsequenceOf :: Monad m => Stream m Int -> m Bool
1059+isPrefixOf :: Monad m => Stream m Int -> m Bool
879−
880isPrefixOf src = S.isPrefixOf src src
1060isPrefixOf src = S.isPrefixOf src src
1061+
1062+{-# INLINE isSubsequenceOf #-}
1063+isSubsequenceOf :: Monad m => Stream m Int -> m Bool
881isSubsequenceOf src = S.isSubsequenceOf src src
1064isSubsequenceOf src = S.isSubsequenceOf src src
882
1065
883{-# INLINE stripPrefix #-}
1066{-# INLINE stripPrefix #-}