git.iko.soy/streamly
on f8d80cc help sign in
streamly/src/Streamly/Internal/Data/Stream/PreludeCommon.hs
139 lines 4.5 kB history raw
1------------------------------------------------------------------------------
2-- Conversion to and from direct style stream
3------------------------------------------------------------------------------
5#ifdef USE_IS_STREAM
6#define IS_STREAM IsStream t,
7#define FROM_STREAM fromStream
8#define TO_STREAM toStream
9#define STREAM t
10#else
11#define IS_STREAM
12#define FROM_STREAM id
13#define TO_STREAM id
14#define STREAM K.Stream
15#endif
17-- These definitions are dependent on what is imported as S
18{-# INLINE fromStreamS #-}
19fromStreamS :: (IS_STREAM Monad m) => S.Stream m a -> STREAM m a
20fromStreamS = FROM_STREAM . S.toStreamK
22{-# INLINE toStreamS #-}
23toStreamS :: (IS_STREAM Monad m) => STREAM m a -> S.Stream m a
24toStreamS = S.fromStreamK . TO_STREAM
26{-# INLINE toStreamD #-}
27toStreamD :: (IS_STREAM Monad m) => STREAM m a -> D.Stream m a
28toStreamD = D.fromStreamK . TO_STREAM
30------------------------------------------------------------------------------
31-- Conversions
32------------------------------------------------------------------------------
34{-# INLINE_EARLY drain #-}
35drain :: (IS_STREAM Monad m) => STREAM m a -> m ()
36drain m = D.drain $ D.fromStreamK (TO_STREAM m)
37{-# RULES "drain fallback to CPS" [1]
38 forall a. D.drain (D.fromStreamK a) = K.drain a #-}
40------------------------------------------------------------------------------
41-- Conversions
42------------------------------------------------------------------------------
44-- |
45-- @
46-- fromList = 'Prelude.foldr' 'K.cons' 'K.nil'
47-- @
48--
49-- Construct a stream from a list of pure values. This is more efficient than
50-- 'K.fromFoldable' for serial streams.
51--
52-- @since 0.4.0
53{-# INLINE_EARLY fromList #-}
54#ifdef USE_IS_STREAM
55fromList :: (Monad m, IsStream t) => [a] -> STREAM m a
56#else
57fromList :: Monad m => [a] -> STREAM m a
58#endif
59fromList = fromStreamS . S.fromList
60{-# RULES "fromList fallback to StreamK" [1]
61 forall a. S.toStreamK (S.fromList a) = K.fromFoldable a #-}
63-- | Convert a stream into a list in the underlying monad.
64--
65-- @since 0.1.0
66{-# INLINE toList #-}
67toList :: (IS_STREAM Monad m) => STREAM m a -> m [a]
68toList m = S.toList $ toStreamS m
70------------------------------------------------------------------------------
71-- Folds
72------------------------------------------------------------------------------
74{-# INLINE foldrM #-}
75foldrM :: (IS_STREAM Monad m) => (a -> m b -> m b) -> m b -> STREAM m a -> m b
76foldrM step acc m = S.foldrM step acc $ toStreamS m
78{-# INLINE foldrMx #-}
79foldrMx :: (IS_STREAM Monad m)
80 => (a -> m x -> m x) -> m x -> (m x -> m b) -> STREAM m a -> m b
81foldrMx step final project m = D.foldrMx step final project $ toStreamD m
83{-# INLINE foldr #-}
84foldr :: (IS_STREAM Monad m) => (a -> b -> b) -> b -> STREAM m a -> m b
85foldr f z = foldrM (\a b -> f a <$> b) (return z)
87-- | Like 'foldlx'', but with a monadic step function.
88--
89-- @since 0.7.0
90{-# INLINE foldlMx' #-}
91foldlMx' ::
92 (IS_STREAM Monad m)
93 => (x -> a -> m x) -> m x -> (x -> m b) -> STREAM m a -> m b
94foldlMx' step begin done m = S.foldlMx' step begin done $ toStreamS m
96-- | Strict left fold with an extraction function. Like the standard strict
97-- left fold, but applies a user supplied extraction function (the third
98-- argument) to the folded value at the end. This is designed to work with the
99-- @foldl@ library. The suffix @x@ is a mnemonic for extraction.
100--
101-- @since 0.7.0
102{-# INLINE foldlx' #-}
103foldlx' ::
104 (IS_STREAM Monad m) => (x -> a -> x) -> x -> (x -> b) -> STREAM m a -> m b
105foldlx' step begin done m = S.foldlx' step begin done $ toStreamS m
107-- | Strict left associative fold.
108--
109-- @since 0.2.0
110{-# INLINE foldl' #-}
111foldl' ::
112 (IS_STREAM Monad m) => (b -> a -> b) -> b -> STREAM m a -> m b
113foldl' step begin m = S.foldl' step begin $ toStreamS m
116{-# INLINE fold #-}
117fold :: (IS_STREAM Monad m) => Fold m a b -> STREAM m a -> m b
118fold fld m = S.fold fld $ toStreamS m
120------------------------------------------------------------------------------
121-- Comparison
122------------------------------------------------------------------------------
124-- | Compare two streams for equality
125--
126-- @since 0.5.3
127{-# INLINE eqBy #-}
128eqBy :: (IS_STREAM Monad m) =>
129 (a -> b -> Bool) -> STREAM m a -> STREAM m b -> m Bool
130eqBy f m1 m2 = D.eqBy f (toStreamD m1) (toStreamD m2)
132-- | Compare two streams
133--
134-- @since 0.5.3
135{-# INLINE cmpBy #-}
136cmpBy
137 :: (IS_STREAM Monad m)
138 => (a -> b -> Ordering) -> STREAM m a -> STREAM m b -> m Ordering
139cmpBy f m1 m2 = D.cmpBy f (toStreamD m1) (toStreamD m2)