@@ -0,0 +1,402 @@
1+---------------------------------
2+Terminology
3+---------------------------------
4+
5+[A]: Added
6+[R]: Removed
7+[C]: Changed
8+[D]: Deprecated
9+[O]: Old
10+[N]: New
11+
12+---------------------------------
13+Difference
14+---------------------------------
15+
16+The moved modules have been compared with their version in streamly v0.8.3
17+
18+[A] Streamly.Unicode.String
19+ [A] str :: QuasiQuoter
20+[C] Streamly.Unicode.Stream
21+ [C] encodeUtf8'
22+ [O] encodeUtf8' :: (Monad m, IsStream t) => t m Char -> t m Word8
23+ [N] encodeUtf8' :: Monad m => Stream m Char -> Stream m Word8
24+ [C] encodeUtf8
25+ [O] encodeUtf8 :: (Monad m, IsStream t) => t m Char -> t m Word8
26+ [N] encodeUtf8 :: Monad m => Stream m Char -> Stream m Word8
27+ [C] encodeStrings
28+ [O] encodeStrings :: (MonadIO m, IsStream t) => (SerialT m Char -> SerialT m Word8) -> t m String -> t m (Array Word8)
29+ [N] encodeStrings :: MonadIO m => (Stream m Char -> Stream m Word8) -> Stream m String -> Stream m (Array Word8)
30+ [C] encodeLatin1'
31+ [O] encodeLatin1' :: (IsStream t, Monad m) => t m Char -> t m Word8
32+ [N] encodeLatin1' :: Monad m => Stream m Char -> Stream m Word8
33+ [C] encodeLatin1
34+ [O] encodeLatin1 :: (IsStream t, Monad m) => t m Char -> t m Word8
35+ [N] encodeLatin1 :: Monad m => Stream m Char -> Stream m Word8
36+ [A] decodeUtf8Chunks :: MonadIO m => Stream m (Array Word8) -> Stream m Char
37+ [C] decodeUtf8'
38+ [O] decodeUtf8' :: (Monad m, IsStream t) => t m Word8 -> t m Char
39+ [N] decodeUtf8' :: Monad m => Stream m Word8 -> Stream m Char
40+ [C] decodeUtf8
41+ [O] decodeUtf8 :: (Monad m, IsStream t) => t m Word8 -> t m Char
42+ [N] decodeUtf8 :: Monad m => Stream m Word8 -> Stream m Char
43+ [C] decodeLatin1
44+ [O] decodeLatin1 :: (IsStream t, Monad m) => t m Word8 -> t m Char
45+ [N] decodeLatin1 :: Monad m => Stream m Word8 -> Stream m Char
46+[A] Streamly.Unicode.Parser
47+ [A] upper :: Monad m => Parser Char m Char
48+ [A] symbol :: Monad m => Parser Char m Char
49+ [A] stringIgnoreCase :: Monad m => String -> Parser Char m String
50+ [A] string :: Monad m => String -> Parser Char m String
51+ [A] space :: Monad m => Parser Char m Char
52+ [A] signed :: (Num a, Monad m) => Parser Char m a -> Parser Char m a
53+ [A] separator :: Monad m => Parser Char m Char
54+ [A] punctuation :: Monad m => Parser Char m Char
55+ [A] printable :: Monad m => Parser Char m Char
56+ [A] octDigit :: Monad m => Parser Char m Char
57+ [A] numeric :: Monad m => Parser Char m Char
58+ [A] mark :: Monad m => Parser Char m Char
59+ [A] lower :: Monad m => Parser Char m Char
60+ [A] letter :: Monad m => Parser Char m Char
61+ [A] latin1 :: Monad m => Parser Char m Char
62+ [A] hexadecimal :: (Monad m, Integral a, Bits a) => Parser Char m a
63+ [A] hexDigit :: Monad m => Parser Char m Char
64+ [A] dropSpace1 :: Monad m => Parser Char m ()
65+ [A] dropSpace :: Monad m => Parser Char m ()
66+ [A] digit :: Monad m => Parser Char m Char
67+ [A] decimal :: (Monad m, Integral a) => Parser Char m a
68+ [A] charIgnoreCase :: Monad m => Char -> Parser Char m Char
69+ [A] char :: Monad m => Char -> Parser Char m Char
70+ [A] asciiUpper :: Monad m => Parser Char m Char
71+ [A] asciiLower :: Monad m => Parser Char m Char
72+ [A] ascii :: Monad m => Parser Char m Char
73+ [A] alphaNum :: Monad m => Parser Char m Char
74+ [A] alpha :: Monad m => Parser Char m Char
75+[C] Streamly.FileSystem.Handle
76+ [D] writeWithBufferOf :: MonadIO m => Int -> Handle -> Fold m Word8 ()
77+ [A] writeWith :: MonadIO m => Int -> Handle -> Fold m Word8 ()
78+ [C] writeChunks
79+ [O] writeChunks :: (MonadIO m, Storable a) => Handle -> Fold m (Array a) ()
80+ [N] writeChunks :: MonadIO m => Handle -> Fold m (Array a) ()
81+ [A] readerWith :: MonadIO m => Unfold m (Int, Handle) Word8
82+ [A] reader :: MonadIO m => Unfold m Handle Word8
83+ [D] readWithBufferOf :: MonadIO m => Unfold m (Int, Handle) Word8
84+ [D] readChunksWithBufferOf :: MonadIO m => Unfold m (Int, Handle) (Array Word8)
85+ [D] readChunks :: MonadIO m => Unfold m Handle (Array Word8)
86+ [D] read :: MonadIO m => Unfold m Handle Word8
87+ [C] putChunk
88+ [O] putChunk :: (MonadIO m, Storable a) => Handle -> Array a -> m ()
89+ [N] putChunk :: MonadIO m => Handle -> Array a -> m ()
90+ [A] chunkReaderWith :: MonadIO m => Unfold m (Int, Handle) (Array Word8)
91+ [A] chunkReader :: MonadIO m => Unfold m Handle (Array Word8)
92+[A] Streamly.FileSystem.File
93+ [A] writeWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Fold m Word8 ()
94+ [A] writeChunks :: (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
95+ [A] write :: (MonadIO m, MonadCatch m) => FilePath -> Fold m Word8 ()
96+ [A] withFile :: (MonadIO m, MonadCatch m) => FilePath -> IOMode -> (Handle -> Stream m a) -> Stream m a
97+ [A] readChunksWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m (Array Word8)
98+ [A] readChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array Word8)
99+ [A] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8
100+[A] Streamly.FileSystem.Dir
101+ [A] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath)
102+ [A] read :: MonadIO m => FilePath -> Stream m FilePath
103+[C] Streamly.Data.Unfold
104+ [C] take
105+ [O] take :: Monad m => Int -> Unfold m a b -> Unfold m a b
106+ [N] take :: Applicative m => Int -> Unfold m a b -> Unfold m a b
107+ [C] replicateM
108+ [O] replicateM :: Monad m => Int -> Unfold m (m a) a
109+ [N] replicateM :: Applicative m => Unfold m (Int, m a) a
110+ [C] repeatM
111+ [O] repeatM :: Monad m => Unfold m (m a) a
112+ [N] repeatM :: Applicative m => Unfold m (m a) a
113+ [C] many
114+ [O] many :: Monad m => Unfold m a b -> Unfold m b c -> Unfold m a c
115+ [N] many :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
116+ [C] iterateM
117+ [O] iterateM :: Monad m => (a -> m a) -> Unfold m (m a) a
118+ [N] iterateM :: Applicative m => (a -> m a) -> Unfold m (m a) a
119+ [C] fromStream
120+ [O] fromStream :: (IsStream t, Monad m) => Unfold m (t m a) a
121+ [N] fromStream :: Applicative m => Unfold m (Stream m a) a
122+ [C] fromListM
123+ [O] fromListM :: Monad m => Unfold m [m a] a
124+ [N] fromListM :: Applicative m => Unfold m [m a] a
125+ [C] fromList
126+ [O] fromList :: Monad m => Unfold m [a] a
127+ [N] fromList :: Applicative m => Unfold m [a] a
128+ [C] drop
129+ [O] drop :: Monad m => Int -> Unfold m a b -> Unfold m a b
130+ [N] drop :: Applicative m => Int -> Unfold m a b -> Unfold m a b
131+[A] Streamly.Data.StreamK
132+ [A] StreamK
133+ [A] zipWithM :: Monad m => (a -> b -> m c) -> StreamK m a -> StreamK m b -> StreamK m c
134+ [A] zipWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
135+ [A] uncons :: Applicative m => StreamK m a -> m (Maybe (a, StreamK m a))
136+ [A] toStream :: Applicative m => StreamK m a -> Stream m a
137+ [A] sortBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> StreamK m a
138+ [A] reverse :: StreamK m a -> StreamK m a
139+ [A] parseChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b)
140+ [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
141+ [A] nilM :: Applicative m => m b -> StreamK m a
142+ [A] nil :: StreamK m a
143+ [A] mergeMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
144+ [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
145+ [A] mergeBy :: (a -> a -> Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
146+ [A] interleave :: StreamK m a -> StreamK m a -> StreamK m a
147+ [A] fromStream :: Monad m => Stream m a -> StreamK m a
148+ [A] fromPure :: a -> StreamK m a
149+ [A] fromFoldable :: Foldable f => f a -> StreamK m a
150+ [A] fromEffect :: Monad m => m a -> StreamK m a
151+ [A] crossWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
152+ [A] consM :: Monad m => m a -> StreamK m a -> StreamK m a
153+ [A] cons :: a -> StreamK m a -> StreamK m a
154+ [A] concatMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
155+ [A] concatEffect :: Monad m => m (StreamK m a) -> StreamK m a
156+ [A] append :: StreamK m a -> StreamK m a -> StreamK m a
157+[A] Streamly.Data.Stream
158+ [A] class Enum a => Enumerable a
159+ [A] Stream
160+ [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
161+ [A] zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
162+ [A] unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
163+ [A] unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a
164+ [A] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b
165+ [A] unfold :: Applicative m => Unfold m a b -> a -> Stream m b
166+ [A] uncons :: Monad m => Stream m a -> m (Maybe (a, Stream m a))
167+ [A] trace :: Monad m => (a -> m b) -> Stream m a -> Stream m a
168+ [A] tap :: Monad m => Fold m a b -> Stream m a -> Stream m a
169+ [A] takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
170+ [A] takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
171+ [A] take :: Applicative m => Int -> Stream m a -> Stream m a
172+ [A] stripPrefix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a))
173+ [A] sequence :: Monad m => Stream m (m a) -> Stream m a
174+ [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b
175+ [A] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b
176+ [A] runStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m (s, a)
177+ [A] runReaderT :: Monad m => m s -> Stream (ReaderT s m) a -> Stream m a
178+ [A] reverse :: Monad m => Stream m a -> Stream m a
179+ [A] replicateM :: Monad m => Int -> m a -> Stream m a
180+ [A] replicate :: Monad m => Int -> a -> Stream m a
181+ [A] repeatM :: Monad m => m a -> Stream m a
182+ [A] repeat :: Monad m => a -> Stream m a
183+ [A] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b
184+ [A] parseMany :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b)
185+ [A] parse :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b)
186+ [A] onException :: MonadCatch m => m b -> Stream m a -> Stream m a
187+ [A] nilM :: Applicative m => m b -> Stream m a
188+ [A] nil :: Applicative m => Stream m a
189+ [A] morphInner :: Monad n => (forall x. m x -> n x) -> Stream m a -> Stream n a
190+ [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a
191+ [A] mergeBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
192+ [A] mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
193+ [A] mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b
194+ [A] mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
195+ [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => Stream m a -> Stream (t m) a
196+ [A] iterateM :: Monad m => (a -> m a) -> m a -> Stream m a
197+ [A] iterate :: Monad m => (a -> a) -> a -> Stream m a
198+ [A] isSubsequenceOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
199+ [A] isPrefixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
200+ [A] intersperseM_ :: Monad m => m b -> Stream m a -> Stream m a
201+ [A] intersperseM :: Monad m => m a -> Stream m a -> Stream m a
202+ [A] intersperse :: Monad m => a -> Stream m a -> Stream m a
203+ [A] interleave :: Monad m => Stream m a -> Stream m a -> Stream m a
204+ [A] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
205+ [A] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
206+ [A] insertBy :: Monad m => (a -> a -> Ordering) -> a -> Stream m a -> Stream m a
207+ [A] indexed :: Monad m => Stream m a -> Stream m (Int, a)
208+ [A] handle :: (MonadCatch m, Exception e) => (e -> Stream m a) -> Stream m a -> Stream m a
209+ [A] fromPure :: Applicative m => a -> Stream m a
210+ [A] fromList :: Applicative m => [a] -> Stream m a
211+ [A] fromEffect :: Applicative m => m a -> Stream m a
212+ [A] foldMany :: Monad m => Fold m a b -> Stream m a -> Stream m b
213+ [A] foldBreak :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)
214+ [A] fold :: Monad m => Fold m a b -> Stream m a -> m b
215+ [A] finallyIO :: (MonadIO m, MonadCatch m) => IO b -> Stream m a -> Stream m a
216+ [A] filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
217+ [A] filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
218+ [A] eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
219+ [A] enumerateTo :: (Monad m, Bounded a, Enumerable a) => a -> Stream m a
220+ [A] enumerateFromTo :: (Enumerable a, Monad m) => a -> a -> Stream m a
221+ [A] enumerateFromThenTo :: (Enumerable a, Monad m) => a -> a -> a -> Stream m a
222+ [A] enumerateFromThen :: (Enumerable a, Monad m) => a -> a -> Stream m a
223+ [A] enumerateFrom :: (Enumerable a, Monad m) => a -> Stream m a
224+ [A] enumerate :: (Monad m, Bounded a, Enumerable a) => Stream m a
225+ [A] dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
226+ [A] dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
227+ [A] drop :: Monad m => Int -> Stream m a -> Stream m a
228+ [A] delay :: MonadIO m => Double -> Stream m a -> Stream m a
229+ [A] crossWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
230+ [A] consM :: Applicative m => m a -> Stream m a -> Stream m a
231+ [A] cons :: Applicative m => a -> Stream m a -> Stream m a
232+ [A] concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
233+ [A] concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
234+ [A] concatEffect :: Monad m => m (Stream m a) -> Stream m a
235+ [A] cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
236+ [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
237+ [A] catRights :: Monad m => Stream m (Either a b) -> Stream m b
238+ [A] catMaybes :: Monad m => Stream m (Maybe a) -> Stream m a
239+ [A] catLefts :: Monad m => Stream m (Either a b) -> Stream m a
240+ [A] catEithers :: Monad m => Stream m (Either a a) -> Stream m a
241+ [A] bracketIO3 :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> IO d) -> (b -> IO e) -> (b -> Stream m a) -> Stream m a
242+ [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
243+ [A] before :: Monad m => m b -> Stream m a -> Stream m a
244+ [A] append :: Monad m => Stream m a -> Stream m a -> Stream m a
245+ [A] afterIO :: MonadIO m => IO b -> Stream m a -> Stream m a
246+[A] Streamly.Data.ParserK
247+ [A] ParserK
248+ [A] fromPure :: b -> ParserK a m b
249+ [A] fromParser :: (Monad m, Unbox a) => Parser a m b -> ParserK a m b
250+ [A] fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK a m b
251+ [A] fromEffect :: Monad m => m b -> ParserK a m b
252+ [A] die :: String -> ParserK a m b
253+[A] Streamly.Data.Parser
254+ [A] Parser
255+ [A] wordWithQuotes :: (Monad m, Eq a) => Bool -> (a -> a -> Maybe a) -> a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b
256+ [A] wordBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
257+ [A] takeWhile1 :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
258+ [A] takeWhile :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
259+ [A] takeEQ :: Monad m => Int -> Fold m a b -> Parser a m b
260+ [A] streamEqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Parser a m ()
261+ [A] some :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
262+ [A] satisfy :: Monad m => (a -> Bool) -> Parser a m a
263+ [A] rmapM :: Monad m => (b -> m c) -> Parser a m b -> Parser a m c
264+ [A] peek :: Monad m => Parser a m a
265+ [A] oneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
266+ [A] one :: Monad m => Parser a m a
267+ [A] noneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
268+ [A] manyTill :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
269+ [A] many :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
270+ [A] lookAhead :: Monad m => Parser a m b -> Parser a m b
271+ [A] lmapM :: Monad m => (a -> m b) -> Parser b m r -> Parser a m r
272+ [A] lmap :: (a -> b) -> Parser b m r -> Parser a m r
273+ [A] listEqBy :: Monad m => (a -> a -> Bool) -> [a] -> Parser a m [a]
274+ [A] listEq :: (Monad m, Eq a) => [a] -> Parser a m [a]
275+ [A] groupBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b
276+ [A] fromPure :: Monad m => b -> Parser a m b
277+ [A] fromFold :: Monad m => Fold m a b -> Parser a m b
278+ [A] fromEffect :: Monad m => m b -> Parser a m b
279+ [A] filter :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
280+ [A] eof :: Monad m => Parser a m ()
281+ [A] dropWhile :: Monad m => (a -> Bool) -> Parser a m ()
282+ [A] die :: Monad m => String -> Parser a m b
283+ [A] deintercalate :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z
284+[A] Streamly.Data.MutArray.Generic
285+ [A] MutArray
286+ [A] writeN :: MonadIO m => Int -> Fold m a (MutArray a)
287+ [A] toList :: MonadIO m => MutArray a -> m [a]
288+ [A] snoc :: MonadIO m => MutArray a -> a -> m (MutArray a)
289+ [A] reader :: MonadIO m => Unfold m (MutArray a) a
290+ [A] putIndex :: MonadIO m => Int -> MutArray a -> a -> m ()
291+ [A] new :: forall m a. MonadIO m => Int -> m (MutArray a)
292+ [A] modifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
293+ [A] getIndex :: MonadIO m => Int -> MutArray a -> m a
294+[A] Streamly.Data.MutArray
295+ [A] class Unbox a
296+ [A] MutArray
297+ [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
298+ [A] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
299+ [A] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
300+ [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
301+ [A] toList :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m [a]
302+ [A] snoc :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
303+ [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
304+ [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
305+ [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
306+ [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
307+ [A] pokeByteIndex :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()
308+ [A] peekByteIndex :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a
309+ [A] newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
310+ [A] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
311+ [A] length :: forall a. Unbox a => MutArray a -> Int
312+ [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
313+ [A] fromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
314+ [A] fromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
315+ [A] cast :: forall a b. Unbox b => MutArray a -> Maybe (MutArray b)
316+ [A] asBytes :: MutArray a -> MutArray Word8
317+[C] Streamly.Data.Fold
318+ [A] Tee
319+ [A] [unTee] :: Tee m a b -> Fold m a b
320+ [A] Tee :: Fold m a b -> Tee m a b
321+ [D] variance :: (Monad m, Fractional a) => Fold m a a
322+ [A] uniqBy :: Monad m => (a -> a -> Bool) -> Fold m a (Maybe a)
323+ [A] topBy :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
324+ [A] toSet :: (Monad m, Ord a) => Fold m a (Set a)
325+ [A] toMapIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
326+ [A] toMap :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
327+ [A] toIntSet :: Monad m => Fold m Int IntSet
328+ [A] the :: (Monad m, Eq a) => Fold m a (Maybe a)
329+ [D] stdDev :: (Monad m, Floating a) => Fold m a a
330+ [A] splitWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
331+ [D] serialWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
332+ [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Fold m b c -> Fold m a c
333+ [A] scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
334+ [A] postscan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
335+ [A] one :: Monad m => Fold m a (Maybe a)
336+ [A] nubInt :: Monad m => Fold m Int (Maybe Int)
337+ [A] nub :: (Monad m, Ord a) => Fold m a (Maybe a)
338+ [A] morphInner :: (forall x. m x -> n x) -> Fold m a b -> Fold n a b
339+ [A] latest :: Monad m => Fold m a (Maybe a)
340+ [D] last :: Monad m => Fold m a (Maybe a)
341+ [D] head :: Monad m => Fold m a (Maybe a)
342+ [A] groupsOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
343+ [A] frequency :: (Monad m, Ord a) => Fold m a (Map a Int)
344+ [A] foldr' :: Monad m => (a -> b -> b) -> b -> Fold m a b
345+ [D] foldr :: Monad m => (a -> b -> b) -> b -> Fold m a b
346+ [A] foldlM1' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
347+ [A] foldl1' :: Monad m => (a -> a -> a) -> Fold m a (Maybe a)
348+ [A] findM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
349+ [A] findIndices :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
350+ [A] elemIndices :: (Monad m, Eq a) => a -> Fold m a (Maybe Int)
351+ [A] duplicate :: Monad m => Fold m a b -> Fold m a (Fold m a b)
352+ [A] drive :: Monad m => Stream m a -> Fold m a b -> m b
353+ [A] drainMapM :: Monad m => (a -> m b) -> Fold m a ()
354+ [D] drainBy :: Monad m => (a -> m b) -> Fold m a ()
355+ [A] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
356+ [A] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
357+ [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
358+ [A] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
359+ [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Fold m a (Maybe a)
360+ [A] countDistinctInt :: Monad m => Fold m Int Int
361+ [A] countDistinct :: (Monad m, Ord a) => Fold m a Int
362+ [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
363+ [A] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
364+ [D] chunksOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
365+ [A] catRights :: Monad m => Fold m b c -> Fold m (Either a b) c
366+ [A] catLefts :: Monad m => Fold m a c -> Fold m (Either a b) c
367+ [A] catEithers :: Fold m a b -> Fold m (Either a a) b
368+ [A] addStream :: Monad m => Stream m a -> Fold m a b -> m (Fold m a b)
369+ [A] addOne :: Monad m => a -> Fold m a b -> m (Fold m a b)
370+[A] Streamly.Data.Array.Generic
371+ [A] Array
372+ [A] writeN :: MonadIO m => Int -> Fold m a (Array a)
373+ [A] write :: MonadIO m => Fold m a (Array a)
374+ [A] reader :: Monad m => Unfold m (Array a) a
375+ [A] readRev :: Monad m => Array a -> Stream m a
376+ [A] read :: MonadIO m => Array a -> Stream m a
377+ [A] length :: Array a -> Int
378+ [A] fromListN :: Int -> [a] -> Array a
379+ [A] fromList :: [a] -> Array a
380+[A] Streamly.Data.Array
381+ [A] class Unbox a
382+ [A] Array
383+ [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
384+ [A] writeLastN :: (Storable a, Unbox a, MonadIO m) => Int -> Fold m a (Array a)
385+ [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
386+ [A] toList :: Unbox a => Array a -> [a]
387+ [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
388+ [A] readerRev :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
389+ [A] reader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
390+ [A] pokeByteIndex :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()
391+ [A] peekByteIndex :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a
392+ [A] length :: Unbox a => Array a -> Int
393+ [A] getIndex :: forall a. Unbox a => Int -> Array a -> Maybe a
394+ [A] fromListN :: Unbox a => Int -> [a] -> Array a
395+ [A] fromList :: Unbox a => [a] -> Array a
396+ [A] cast :: forall a b. Unbox b => Array a -> Maybe (Array b)
397+ [A] asBytes :: Array a -> Array Word8
398+[C] Streamly.Console.Stdio
399+ [A] reader :: MonadIO m => Unfold m () Word8
400+ [D] readChunks :: MonadIO m => Unfold m () (Array Word8)
401+ [D] read :: MonadIO m => Unfold m () Word8
402+ [A] chunkReader :: MonadIO m => Unfold m () (Array Word8)