@@ -287,56 +287,6 @@ currentTime value g _ = S.take value $ Internal.currentTime g
287287runStream :: Monad m => Stream m a -> m ()
288288runStream = S.drain
289289
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−
340290{-# INLINE toNull #-}
341291toNull :: Monad m => (t m a -> S.SerialT m a) -> t m a -> m ()
342292toNull t = runStream . t
@@ -367,8 +317,10 @@ nullHeadTail s = do
367317
368318{-# INLINE mapM_ #-}
369319mapM_ :: Monad m => Stream m Int -> m ()
370−mapM_ = S.mapM_ (\_ -> return ())
320+mapM_ = S.mapM_ (\_ -> return ())
371321
322+{-# INLINE toList #-}
323+toList :: Monad m => Stream m Int -> m [Int]
372324toList = S.toList
373325
374326{-# INLINE toListRev #-}
@@ -377,41 +329,125 @@ toListRev = Internal.toListRev
377329
378330{-# INLINE foldrMElem #-}
379331foldrMElem :: Monad m => Int -> Stream m Int -> m Bool
380−foldrMElem e m = S.foldrM (\x xs -> if x == e then return P.True else xs)
381− (return P.False) m
332+foldrMElem e m =
333+ S.foldrM
334+ (\x xs ->
335+ if x == e
336+ then return P.True
337+ else xs)
338+ (return P.False)
339+ m
382340
383341{-# INLINE foldrMToStream #-}
384342foldrMToStream :: 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 [])
386348
387−foldrMBuild = S.foldrM (\x xs -> xs >>= return . (x :)) (return [])
349+{-# INLINE foldl'Build #-}
350+foldl'Build :: Monad m => Stream m Int -> m [Int]
388351foldl'Build = S.foldl' (flip (:)) []
352+
353+{-# INLINE foldlM'Build #-}
354+foldlM'Build :: Monad m => Stream m Int -> m [Int]
389355foldlM'Build = S.foldlM' (\xs x -> return $ x : xs) []
390356
357+{-# INLINE foldrMReduce #-}
358+foldrMReduce :: Monad m => Stream m Int -> m Int
391359foldrMReduce = S.foldrM (\x xs -> xs >>= return . (x +)) (return 0)
360+
361+{-# INLINE foldl'Reduce #-}
362+foldl'Reduce :: Monad m => Stream m Int -> m Int
392363foldl'Reduce = S.foldl' (+) 0
393−foldl'ReduceMap = P.fmap (+1) . S.foldl' (+) 0
364+
365+{-# INLINE foldl'ReduceMap #-}
366+foldl'ReduceMap :: Monad m => Stream m Int -> m Int
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)
394371foldl1'Reduce = S.foldl1' (+)
372+
373+{-# INLINE foldlM'Reduce #-}
374+foldlM'Reduce :: Monad m => Stream m Int -> m Int
395375foldlM'Reduce = S.foldlM' (\xs a -> return $ a + xs) 0
396376
397−last = S.last
398−_null = S.null
399−_head = S.head
400−elem value = S.elem (value + 1)
377+{-# INLINE last #-}
378+last :: Monad m => Stream m Int -> m (Maybe Int)
379+last = S.last
380+
381+{-# INLINE _null #-}
382+_null :: Monad m => Stream m Int -> m Bool
383+_null = S.null
384+
385+{-# INLINE _head #-}
386+_head :: Monad m => Stream m Int -> m (Maybe Int)
387+_head = S.head
388+
389+{-# INLINE elem #-}
390+elem :: Monad m => Int -> Stream m Int -> m Bool
391+elem value = S.elem (value + 1)
392+
393+{-# INLINE notElem #-}
394+notElem :: Monad m => Int -> Stream m Int -> m Bool
401395notElem value = S.notElem (value + 1)
396+
397+{-# INLINE length #-}
398+length :: Monad m => Stream m Int -> m Int
402399length = S.length
403−all value = S.all (<= (value + 1))
404−any value = S.any (> (value + 1))
405−and value = S.and . S.map (<= (value + 1))
406−or value = S.or . S.map (> (value + 1))
407−find value = S.find (== (value + 1))
400+
401+{-# INLINE all #-}
402+all :: Monad m => Int -> Stream m Int -> m Bool
403+all value = S.all (<= (value + 1))
404+
405+{-# INLINE any #-}
406+any :: Monad m => Int -> Stream m Int -> m Bool
407+any value = S.any (> (value + 1))
408+
409+{-# INLINE and #-}
410+and :: Monad m => Int -> Stream m Int -> m Bool
411+and value = S.and . S.map (<= (value + 1))
412+
413+{-# INLINE or #-}
414+or :: Monad m => Int -> Stream m Int -> m Bool
415+or value = S.or . S.map (> (value + 1))
416+
417+{-# INLINE find #-}
418+find :: Monad m => Int -> Stream m Int -> m (Maybe Int)
419+find value = S.find (== (value + 1))
420+
421+{-# INLINE findIndex #-}
422+findIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)
408423findIndex value = S.findIndex (== (value + 1))
424+
425+{-# INLINE elemIndex #-}
426+elemIndex :: Monad m => Int -> Stream m Int -> m (Maybe Int)
409427elemIndex value = S.elemIndex (value + 1)
428+
429+{-# INLINE maximum #-}
430+maximum :: Monad m => Stream m Int -> m (Maybe Int)
410431maximum = S.maximum
432+
433+{-# INLINE minimum #-}
434+minimum :: Monad m => Stream m Int -> m (Maybe Int)
411435minimum = S.minimum
412−sum = S.sum
436+
437+{-# INLINE sum #-}
438+sum :: Monad m => Stream m Int -> m Int
439+sum = S.sum
440+
441+{-# INLINE product #-}
442+product :: Monad m => Stream m Int -> m Int
413443product = S.product
444+
445+{-# INLINE minimumBy #-}
446+minimumBy :: Monad m => Stream m Int -> m (Maybe Int)
414447minimumBy = S.minimumBy compare
448+
449+{-# INLINE maximumBy #-}
450+maximumBy :: Monad m => Stream m Int -> m (Maybe Int)
415451maximumBy = S.maximumBy compare
416452
417453-------------------------------------------------------------------------------
@@ -423,9 +459,12 @@ transform :: Monad m => Stream m a -> m ()
423459transform = runStream
424460
425461{-# INLINE composeN #-}
426−composeN
427− :: MonadIO m
428− => Int -> (Stream m Int -> Stream m Int) -> Stream m Int -> m ()
462+composeN ::
463+ MonadIO m
464+ => Int
465+ -> (Stream m Int -> Stream m Int)
466+ -> Stream m Int
467+ -> m ()
429468composeN n f =
430469 case n of
431470 1 -> transform . f
@@ -436,9 +475,12 @@ composeN n f =
436475
437476-- polymorphic stream version of composeN
438477{-# INLINE composeN' #-}
439−composeN'
440− :: (S.IsStream t, Monad m)
441− => Int -> (t m Int -> Stream m Int) -> t m Int -> m ()
478+composeN' ::
479+ (S.IsStream t, Monad m)
480+ => Int
481+ -> (t m Int -> Stream m Int)
482+ -> t m Int
483+ -> m ()
442484composeN' n f =
443485 case n of
444486 1 -> transform . f
@@ -448,71 +490,47 @@ composeN' n f =
448490 _ -> undefined
449491
450492{-# INLINE scan #-}
493+scan :: MonadIO m => Int -> Stream m Int -> m ()
494+scan n = composeN n $ S.scanl' (+) 0
495+
451496{-# 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 ()
483−
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 ()
497+scanl1' :: MonadIO m => Int -> Stream m Int -> m ()
498+scanl1' n = composeN n $ S.scanl1' (+)
490499
491−{-# INLINE mapMaybeM #-}
492−{-# INLINE intersperse #-}
493−mapMaybeM :: S.MonadAsync m => Int -> Stream m Int -> m ()
494−intersperse :: S.MonadAsync m => Int -> Int -> Stream m Int -> m ()
500+{-# INLINE fmap #-}
501+fmap :: MonadIO m => Int -> Stream m Int -> m ()
502+fmap n = composeN n $ P.fmap (+ 1)
495503
496−{-# INLINE mapM #-}
497−{-# INLINE map' #-}
498504{-# INLINE fmap' #-}
499−mapM, map' :: (S.IsStream t, S.MonadAsync m)
500− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
505+fmap' ::
506+ (S.IsStream t, S.MonadAsync m, P.Functor (t 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)
501512
502−fmap' :: (S.IsStream t, S.MonadAsync m, P.Functor (t m))
503− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
513+{-# INLINE map #-}
514+map :: MonadIO m => Int -> Stream m Int -> m ()
515+map n = composeN n $ S.map (+ 1)
504516
505−{-# INLINE sequence #-}
506−sequence :: (S.IsStream t, S.MonadAsync m)
507− => (t m Int -> S.SerialT m Int) -> t m (m Int) -> m ()
517+{-# INLINE map' #-}
518+map' ::
519+ (S.IsStream t, S.MonadAsync 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)
508525
509−scan n = composeN n $ S.scanl' (+) 0
510−scanl1' n = composeN n $ S.scanl1' (+)
511−fmap n = composeN n $ P.fmap (+1)
512−fmap' t n = composeN' n $ t . P.fmap (+1)
513−map n = composeN n $ S.map (+1)
514−map' t n = composeN' n $ t . S.map (+1)
515−mapM t n = composeN' n $ t . S.mapM return
526+{-# INLINE mapM #-}
527+mapM ::
528+ (S.IsStream t, S.MonadAsync m)
529+ => (t m Int -> S.SerialT m Int)
530+ -> Int
531+ -> t m Int
532+ -> m ()
533+mapM t n = composeN' n $ t . S.mapM return
516534
517535{-# INLINE tap #-}
518536tap :: MonadIO m => Int -> Stream m Int -> m ()
@@ -528,7 +546,8 @@ tapRate n str = do
528546pollCounts :: Int -> Stream IO Int -> IO ()
529547pollCounts n str = do
530548 composeN n (Internal.pollCounts (P.const P.True) f FL.drain) str
531− where f = Internal.rollingMap (P.-) . Internal.delayPost 1
549+ where
550+ f = Internal.rollingMap (P.-) . Internal.delayPost 1
532551
533552{-# INLINE tapAsyncS #-}
534553tapAsyncS :: S.MonadAsync m => Int -> Stream m Int -> m ()
@@ -538,34 +557,125 @@ tapAsyncS n = composeN n $ Par.tapAsync S.sum
538557tapAsync :: S.MonadAsync m => Int -> Stream m Int -> m ()
539558tapAsync n = composeN n $ Internal.tapAsync FL.sum
540559
541−mapMaybe n = composeN n $ S.mapMaybe
542− (\x -> if P.odd x then Nothing else Just x)
543−mapMaybeM n = composeN n $ S.mapMaybeM
544− (\x -> if P.odd x then return Nothing else return $ Just x)
545−sequence t = transform . t . S.sequence
546−filterEven n = composeN n $ S.filter even
547−filterAllOut value n = composeN n $ S.filter (> (value + 1))
548−filterAllIn value n = composeN n $ S.filter (<= (value + 1))
549−_takeOne n = composeN n $ S.take 1
550−takeAll value n = composeN n $ S.take (value + 1)
560+{-# INLINE mapMaybe #-}
561+mapMaybe :: MonadIO m => Int -> Stream m Int -> m ()
562+mapMaybe n =
563+ composeN n $
564+ S.mapMaybe
565+ (\x ->
566+ if P.odd x
567+ then Nothing
568+ else Just x)
569+
570+{-# INLINE mapMaybeM #-}
571+mapMaybeM :: S.MonadAsync m => Int -> Stream m Int -> m ()
572+mapMaybeM n =
573+ composeN n $
574+ S.mapMaybeM
575+ (\x ->
576+ if P.odd 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 ()
586+sequence t = transform . t . S.sequence
587+
588+{-# INLINE filterEven #-}
589+filterEven :: MonadIO m => Int -> Stream m Int -> m ()
590+filterEven n = composeN n $ S.filter even
591+
592+{-# INLINE filterAllOut #-}
593+filterAllOut :: MonadIO m => Int -> Int -> Stream m Int -> m ()
594+filterAllOut value n = composeN n $ S.filter (> (value + 1))
595+
596+{-# INLINE filterAllIn #-}
597+filterAllIn :: MonadIO m => Int -> Int -> Stream m Int -> m ()
598+filterAllIn value n = composeN n $ S.filter (<= (value + 1))
599+
600+{-# INLINE _takeOne #-}
601+_takeOne :: MonadIO m => Int -> Stream m Int -> m ()
602+_takeOne n = composeN n $ S.take 1
603+
604+{-# INLINE takeAll #-}
605+takeAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()
606+takeAll value n = composeN n $ S.take (value + 1)
607+
608+{-# INLINE takeWhileTrue #-}
609+takeWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
551610takeWhileTrue value n = composeN n $ S.takeWhile (<= (value + 1))
611+
612+{-# INLINE _takeWhileMTrue #-}
613+_takeWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
552614_takeWhileMTrue value n = composeN n $ S.takeWhileM (return . (<= (value + 1)))
553−dropOne n = composeN n $ S.drop 1
554−dropAll value n = composeN n $ S.drop (value + 1)
555−dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))
615+
616+{-# INLINE dropOne #-}
617+dropOne :: MonadIO m => Int -> Stream m Int -> m ()
618+dropOne n = composeN n $ S.drop 1
619+
620+{-# INLINE dropAll #-}
621+dropAll :: MonadIO m => Int -> Int -> Stream m Int -> m ()
622+dropAll value n = composeN n $ S.drop (value + 1)
623+
624+{-# INLINE dropWhileTrue #-}
625+dropWhileTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
626+dropWhileTrue value n = composeN n $ S.dropWhile (<= (value + 1))
627+
628+{-# INLINE _dropWhileMTrue #-}
629+_dropWhileMTrue :: MonadIO m => Int -> Int -> Stream m Int -> m ()
556630_dropWhileMTrue value n = composeN n $ S.dropWhileM (return . (<= (value + 1)))
631+
632+{-# INLINE dropWhileFalse #-}
633+dropWhileFalse :: MonadIO m => Int -> Int -> Stream m Int -> m ()
557634dropWhileFalse value n = composeN n $ S.dropWhile (> (value + 1))
558−findIndices value n = composeN n $ S.findIndices (== (value + 1))
559−elemIndices value n = composeN n $ S.elemIndices (value + 1)
560−intersperse value n = composeN n $ S.intersperse (value + 1)
561−insertBy value n = composeN n $ S.insertBy compare (value + 1)
562−deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)
563−reverse n = composeN n $ S.reverse
564−reverse' n = composeN n $ Internal.reverse'
565−foldrS n = composeN n $ Internal.foldrS S.cons S.nil
566−foldrSMap n = composeN n $ Internal.foldrS (\x xs -> x + 1 `S.cons` xs) S.nil
567−foldrT n = composeN n $ Internal.foldrT S.cons S.nil
568−foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
635+
636+{-# INLINE findIndices #-}
637+findIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()
638+findIndices value n = composeN n $ S.findIndices (== (value + 1))
639+
640+{-# INLINE elemIndices #-}
641+elemIndices :: MonadIO m => Int -> Int -> Stream m Int -> m ()
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 ()
646+intersperse value n = composeN n $ S.intersperse (value + 1)
647+
648+{-# INLINE insertBy #-}
649+insertBy :: MonadIO m => Int -> Int -> Stream m Int -> m ()
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 ()
654+deleteBy value n = composeN n $ S.deleteBy (>=) (value + 1)
655+
656+{-# INLINE reverse #-}
657+reverse :: MonadIO m => Int -> Stream m Int -> m ()
658+reverse n = composeN n $ S.reverse
659+
660+{-# INLINE reverse' #-}
661+reverse' :: MonadIO m => Int -> Stream m Int -> m ()
662+reverse' n = composeN n $ Internal.reverse'
663+
664+{-# INLINE foldrS #-}
665+foldrS :: MonadIO m => Int -> Stream m Int -> m ()
666+foldrS n = composeN n $ Internal.foldrS S.cons S.nil
667+
668+{-# INLINE foldrSMap #-}
669+foldrSMap :: MonadIO m => Int -> Stream m Int -> m ()
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 ()
674+foldrT n = composeN n $ Internal.foldrT S.cons S.nil
675+
676+{-# INLINE foldrTMap #-}
677+foldrTMap :: MonadIO m => Int -> Stream m Int -> m ()
678+foldrTMap n = composeN n $ Internal.foldrT (\x xs -> x + 1 `S.cons` xs) S.nil
569679
570680{-# INLINE takeByTime #-}
571681takeByTime :: NanoSecond64 -> Int -> Stream IO Int -> IO ()
@@ -591,121 +701,183 @@ inspect $ hasNoTypeClasses 'dropByTime
591701-------------------------------------------------------------------------------
592702
593703{-# 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+
594712{-# INLINE transformComposeMapM #-}
595−{-# INLINE transformTeeMapM #-}
596−{-# INLINE transformZipMapM #-}
713+transformComposeMapM ::
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)))
597725
598−transformMapM, transformComposeMapM, transformTeeMapM,
599− transformZipMapM :: (S.IsStream t, S.MonadAsync m)
600− => (t m Int -> S.SerialT m Int) -> Int -> t m Int -> m ()
726+{-# INLINE transformTeeMapM #-}
727+transformTeeMapM ::
728+ (S.IsStream t, S.MonadAsync 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)))
601739
602−transformMapM t n = composeN' n $ t . Internal.transform (Pipe.mapM return)
603−transformComposeMapM t n = composeN' n $ t . Internal.transform
604− (Pipe.mapM (\x -> return (x + 1))
605− `Pipe.compose` Pipe.mapM (\x -> return (x + 2)))
606−transformTeeMapM t n = composeN' n $ t . Internal.transform
607− (Pipe.mapM (\x -> return (x + 1))
608− `Pipe.tee` Pipe.mapM (\x -> return (x + 2)))
609−transformZipMapM t n = composeN' n $ t . Internal.transform
610− (Pipe.zipWith (+) (Pipe.mapM (\x -> return (x + 1)))
611− (Pipe.mapM (\x -> return (x + 2))))
740+{-# INLINE transformZipMapM #-}
741+transformZipMapM ::
742+ (S.IsStream t, S.MonadAsync m)
743+ => (t m Int -> S.SerialT m Int)
744+ -> Int
745+ -> t m Int
746+ -> m ()
747+transformZipMapM t n =
748+ composeN' n $
749+ t .
750+ Internal.transform
751+ (Pipe.zipWith
752+ (+)
753+ (Pipe.mapM (\x -> return (x + 1)))
754+ (Pipe.mapM (\x -> return (x + 2))))
612755
613756-------------------------------------------------------------------------------
614757-- Mixed Transformation
615758-------------------------------------------------------------------------------
616759
617760{-# INLINE scanMap #-}
761+scanMap :: MonadIO m => Int -> Stream m Int -> m ()
762+scanMap n = composeN n $ S.map (subtract 1) . S.scanl' (+) 0
763+
618764{-# INLINE dropMap #-}
765+dropMap :: MonadIO m => Int -> Stream m Int -> m ()
766+dropMap n = composeN n $ S.map (subtract 1) . S.drop 1
767+
619768{-# INLINE dropScan #-}
769+dropScan :: MonadIO m => Int -> Stream m Int -> m ()
770+dropScan n = composeN n $ S.scanl' (+) 0 . S.drop 1
771+
620772{-# 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+
621776{-# 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+
622780{-# 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+
623784{-# 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 ()
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)
785+filterDrop :: MonadIO m => Int -> Int -> Stream m Int -> m ()
642786filterDrop 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 ()
643790filterTake 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 ()
644794filterScan n = composeN n $ S.scanl' (+) 0 . S.filter (<= maxBound)
795+
796+{-# INLINE filterScanl1 #-}
797+filterScanl1 :: MonadIO m => Int -> Stream m Int -> m ()
645798filterScanl1 n = composeN n $ S.scanl1' (+) . S.filter (<= maxBound)
646−filterMap value n = composeN n $ S.map (subtract 1) . S.filter (<= (value + 1))
799+
800+{-# INLINE filterMap #-}
801+filterMap :: MonadIO m => Int -> Int -> Stream m Int -> m ()
802+filterMap value n = composeN n $ S.map (subtract 1) . S.filter (<= (value + 1))
647803
648804-------------------------------------------------------------------------------
649805-- Scan and fold
650806-------------------------------------------------------------------------------
651807
652−data Pair a b = Pair !a !b deriving (Generic, NFData)
808+data Pair a b =
809+ Pair !a !b
810+ deriving (Generic, NFData)
653811
654812{-# INLINE sumProductFold #-}
655813sumProductFold :: 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)
657815
658816{-# INLINE sumProductScan #-}
659817sumProductScan :: Monad m => Stream m Int -> m (Pair Int Int)
660−sumProductScan = S.foldl' (\(Pair _ p) (s0,x) -> Pair s0 (p P.* x)) (Pair 0 1)
661− . S.scanl' (\(s,_) x -> (s + x,x)) (0,0)
818+sumProductScan =
819+ S.foldl' (\(Pair _ p) (s0, x) -> Pair s0 (p P.* x)) (Pair 0 1) .
820+ S.scanl' (\(s, _) x -> (s + x, x)) (0, 0)
662821
663822-------------------------------------------------------------------------------
664823-- Iteration
665824-------------------------------------------------------------------------------
666825
667−iterStreamLen, maxIters :: Int
826+{-# INLINE iterStreamLen #-}
827+iterStreamLen :: Int
668828iterStreamLen = 10
829+
830+{-# INLINE maxIters #-}
831+maxIters :: Int
669832maxIters = 10000
670833
671834{-# INLINE iterateSource #-}
672−iterateSource
673− :: S.MonadAsync m
674− => (Stream m Int -> Stream m Int) -> Int -> Int -> Stream m Int
835+iterateSource ::
836+ S.MonadAsync m
837+ => (Stream m Int -> Stream m Int)
838+ -> Int
839+ -> Int
840+ -> Stream m Int
675841iterateSource g i n = f i (sourceUnfoldrMN iterStreamLen n)
676− where
677− f (0 :: Int) m = g m
678− f x m = g (f (x P.- 1) m)
842+ where
843+ f (0 :: Int) m = g m
844+ f x m = g (f (x P.- 1) m)
679845
680−{-# INLINE iterateMapM #-}
846+-- this is quadratic
681847{-# 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
682852{-# 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+
683860{-# INLINE iterateFilterEven #-}
861+iterateFilterEven :: S.MonadAsync m => Int -> Stream m Int
862+iterateFilterEven = iterateSource (S.filter even) maxIters
863+
684864{-# 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
692867
693−iterateTakeAll,
694− iterateDropWhileFalse, iterateDropWhileTrue
695− :: S.MonadAsync m
696− => Int -> Int -> Stream m Int
868+{-# INLINE iterateDropOne #-}
869+iterateDropOne :: S.MonadAsync m => Int -> Stream m Int
870+iterateDropOne = iterateSource (S.drop 1) maxIters
697871
698−-- this is quadratic
699−iterateScan = iterateSource (S.scanl' (+) 0) (maxIters `div` 10)
700−-- so is this
701−iterateScanl1 = iterateSource (S.scanl1' (+)) (maxIters `div` 10)
872+{-# INLINE iterateDropWhileFalse #-}
873+iterateDropWhileFalse :: S.MonadAsync m => Int -> Int -> Stream m Int
874+iterateDropWhileFalse value =
875+ iterateSource (S.dropWhile (> (value + 1))) maxIters
702876
703−iterateMapM = iterateSource (S.mapM return) maxIters
704−iterateFilterEven = iterateSource (S.filter even) maxIters
705−iterateTakeAll value = iterateSource (S.take (value + 1)) maxIters
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
877+{-# INLINE iterateDropWhileTrue #-}
878+iterateDropWhileTrue :: S.MonadAsync m => Int -> Int -> Stream m Int
879+iterateDropWhileTrue value =
880+ iterateSource (S.dropWhile (<= (value + 1))) maxIters
709881
710882-------------------------------------------------------------------------------
711883-- Combining streams
@@ -718,34 +890,35 @@ iterateDropWhileTrue value = iterateSource (S.dropWhile (<= (value + 1))) maxI
718890{-# INLINE serial2 #-}
719891serial2 :: Int -> Int -> IO ()
720892serial2 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))
724894
725895{-# INLINE serial4 #-}
726896serial4 :: Int -> Int -> IO ()
727897serial4 count n =
728− S.drain $ S.serial
729− ((S.serial (sourceUnfoldrMN count n)
730− (sourceUnfoldrMN count (n + 1))))
731− ((S.serial (sourceUnfoldrMN count (n+2))
732− (sourceUnfoldrMN count (n + 3))))
898+ S.drain $
899+ S.serial
900+ ((S.serial (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))))
901+ ((S.serial
902+ (sourceUnfoldrMN count (n + 2))
903+ (sourceUnfoldrMN count (n + 3))))
733904
734905{-# INLINE append2 #-}
735906append2 :: Int -> Int -> IO ()
736907append2 count n =
737− S.drain $ Internal.append
738− (sourceUnfoldrMN count n)
739− (sourceUnfoldrMN count (n + 1))
908+ S.drain $
909+ Internal.append (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))
740910
741911{-# INLINE append4 #-}
742912append4 :: Int -> Int -> IO ()
743913append4 count n =
744− S.drain $ Internal.append
745− ((Internal.append (sourceUnfoldrMN count n)
746− (sourceUnfoldrMN count (n + 1))))
747− ((Internal.append (sourceUnfoldrMN count (n+2))
748− (sourceUnfoldrMN count (n + 3))))
914+ S.drain $
915+ Internal.append
916+ ((Internal.append
917+ (sourceUnfoldrMN count n)
918+ (sourceUnfoldrMN count (n + 1))))
919+ ((Internal.append
920+ (sourceUnfoldrMN count (n + 2))
921+ (sourceUnfoldrMN count (n + 3))))
749922
750923#ifdef INSPECTION
751924inspect $ hasNoTypeClasses 'append2
@@ -759,15 +932,19 @@ inspect $ 'append2 `hasNoType` ''D.AppendState
759932
760933{-# INLINE wSerial2 #-}
761934wSerial2 :: Int -> Int -> IO ()
762−wSerial2 value n = S.drain $ S.wSerial
763− (sourceUnfoldrMN (value `div` 2) n)
764− (sourceUnfoldrMN (value `div` 2) (n + 1))
935+wSerial2 value n =
936+ S.drain $
937+ S.wSerial
938+ (sourceUnfoldrMN (value `div` 2) n)
939+ (sourceUnfoldrMN (value `div` 2) (n + 1))
765940
766941{-# INLINE interleave2 #-}
767942interleave2 :: Int -> Int -> IO ()
768−interleave2 value n = S.drain $ Internal.interleave
769− (sourceUnfoldrMN (value `div` 2) n)
770− (sourceUnfoldrMN (value `div` 2) (n + 1))
943+interleave2 value n =
944+ S.drain $
945+ Internal.interleave
946+ (sourceUnfoldrMN (value `div` 2) n)
947+ (sourceUnfoldrMN (value `div` 2) (n + 1))
771948
772949#ifdef INSPECTION
773950inspect $ hasNoTypeClasses 'interleave2
@@ -777,9 +954,11 @@ inspect $ 'interleave2 `hasNoType` ''D.InterleaveState
777954
778955{-# INLINE roundRobin2 #-}
779956roundRobin2 :: Int -> Int -> IO ()
780−roundRobin2 value n = S.drain $ Internal.roundrobin
781− (sourceUnfoldrMN (value `div` 2) n)
782− (sourceUnfoldrMN (value `div` 2) (n + 1))
957+roundRobin2 value n =
958+ S.drain $
959+ Internal.roundrobin
960+ (sourceUnfoldrMN (value `div` 2) n)
961+ (sourceUnfoldrMN (value `div` 2) (n + 1))
783962
784963#ifdef INSPECTION
785964inspect $ hasNoTypeClasses 'roundRobin2
@@ -794,7 +973,9 @@ inspect $ 'roundRobin2 `hasNoType` ''D.InterleaveState
794973{-# INLINE mergeBy #-}
795974mergeBy :: Int -> Int -> IO ()
796975mergeBy count n =
797− S.drain $ S.mergeBy P.compare
976+ S.drain $
977+ S.mergeBy
978+ P.compare
798979 (sourceUnfoldrMN count n)
799980 (sourceUnfoldrMN count (n + 1))
800981
@@ -811,9 +992,8 @@ inspect $ 'mergeBy `hasNoType` ''D.Step
811992{-# INLINE zip #-}
812993zip :: Int -> Int -> IO ()
813994zip count n =
814− S.drain $ S.zipWith (,)
815− (sourceUnfoldrMN count n)
816− (sourceUnfoldrMN count (n + 1))
995+ S.drain $
996+ S.zipWith (,) (sourceUnfoldrMN count n) (sourceUnfoldrMN count (n + 1))
817997
818998#ifdef INSPECTION
819999inspect $ hasNoTypeClasses 'zip
@@ -824,7 +1004,9 @@ inspect $ 'zip `hasNoType` ''D.Step
8241004{-# INLINE zipM #-}
8251005zipM :: Int -> Int -> IO ()
8261006zipM count n =
827− S.drain $ S.zipWithM (curry return)
1007+ S.drain $
1008+ S.zipWithM
1009+ (curry return)
8281010 (sourceUnfoldrMN count n)
8291011 (sourceUnfoldrMN count (n + 1))
8301012
@@ -837,35 +1019,35 @@ inspect $ 'zipM `hasNoType` ''D.Step
8371019{-# INLINE zipAsync #-}
8381020zipAsync :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
8391021zipAsync 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))
8431023
8441024{-# INLINE zipAsyncM #-}
8451025zipAsyncM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
8461026zipAsyncM count n = do
847− S.zipAsyncWithM (curry return)
1027+ S.zipAsyncWithM
1028+ (curry return)
8481029 (sourceUnfoldrMN count n)
8491030 (sourceUnfoldrMN count (n + 1))
8501031
8511032{-# INLINE zipAsyncAp #-}
8521033zipAsyncAp :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m (Int, Int)
853−zipAsyncAp count n = do
854− S.zipAsyncly $ (,)
855− <$> (sourceUnfoldrMN count n)
856− <*> (sourceUnfoldrMN count (n + 1))
1034+zipAsyncAp count n = do
1035+ S.zipAsyncly $
1036+ (,) <$> (sourceUnfoldrMN count n) <*> (sourceUnfoldrMN count (n + 1))
8571037
8581038{-# INLINE mergeAsyncByM #-}
8591039mergeAsyncByM :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
8601040mergeAsyncByM count n = do
861− S.mergeAsyncByM (\a b -> return (a `compare` b))
1041+ S.mergeAsyncByM
1042+ (\a b -> return (a `compare` b))
8621043 (sourceUnfoldrMN count n)
8631044 (sourceUnfoldrMN count (n + 1))
8641045
8651046{-# INLINE mergeAsyncBy #-}
8661047mergeAsyncBy :: (S.IsStream t, S.MonadAsync m) => Int -> Int -> t m Int
8671048mergeAsyncBy count n = do
868− S.mergeAsyncBy compare
1049+ S.mergeAsyncBy
1050+ compare
8691051 (sourceUnfoldrMN count n)
8701052 (sourceUnfoldrMN count (n + 1))
8711053
@@ -874,10 +1056,11 @@ mergeAsyncBy count n = do
8741056-------------------------------------------------------------------------------
8751057
8761058{-# INLINE isPrefixOf #-}
877−{-# INLINE isSubsequenceOf #-}
878−isPrefixOf, isSubsequenceOf :: Monad m => Stream m Int -> m Bool
879−
1059+isPrefixOf :: Monad m => Stream m Int -> m Bool
8801060isPrefixOf src = S.isPrefixOf src src
1061+
1062+{-# INLINE isSubsequenceOf #-}
1063+isSubsequenceOf :: Monad m => Stream m Int -> m Bool
8811064isSubsequenceOf src = S.isSubsequenceOf src src
8821065
8831066{-# INLINE stripPrefix #-}