---------------------------------
Terminology
---------------------------------

[A]: Added
[R]: Removed
[C]: Changed
[D]: Deprecated
[O]: Old
[N]: New

---------------------------------
Difference
---------------------------------

The moved modules have been compared with their version in streamly v0.8.3

[A] Streamly.Unicode.String
    [A] str :: QuasiQuoter
[C] Streamly.Unicode.Stream
    [C] encodeUtf8'
        [O] encodeUtf8' :: (Monad m, IsStream t) => t m Char -> t m Word8
        [N] encodeUtf8' :: Monad m => Stream m Char -> Stream m Word8
    [C] encodeUtf8
        [O] encodeUtf8 :: (Monad m, IsStream t) => t m Char -> t m Word8
        [N] encodeUtf8 :: Monad m => Stream m Char -> Stream m Word8
    [C] encodeStrings
        [O] encodeStrings :: (MonadIO m, IsStream t) => (SerialT m Char -> SerialT m Word8) -> t m String -> t m (Array Word8)
        [N] encodeStrings :: MonadIO m => (Stream m Char -> Stream m Word8) -> Stream m String -> Stream m (Array Word8)
    [C] encodeLatin1'
        [O] encodeLatin1' :: (IsStream t, Monad m) => t m Char -> t m Word8
        [N] encodeLatin1' :: Monad m => Stream m Char -> Stream m Word8
    [C] encodeLatin1
        [O] encodeLatin1 :: (IsStream t, Monad m) => t m Char -> t m Word8
        [N] encodeLatin1 :: Monad m => Stream m Char -> Stream m Word8
    [A] decodeUtf8Chunks :: MonadIO m => Stream m (Array Word8) -> Stream m Char
    [C] decodeUtf8'
        [O] decodeUtf8' :: (Monad m, IsStream t) => t m Word8 -> t m Char
        [N] decodeUtf8' :: Monad m => Stream m Word8 -> Stream m Char
    [C] decodeUtf8
        [O] decodeUtf8 :: (Monad m, IsStream t) => t m Word8 -> t m Char
        [N] decodeUtf8 :: Monad m => Stream m Word8 -> Stream m Char
    [C] decodeLatin1
        [O] decodeLatin1 :: (IsStream t, Monad m) => t m Word8 -> t m Char
        [N] decodeLatin1 :: Monad m => Stream m Word8 -> Stream m Char
[A] Streamly.Unicode.Parser
    [A] upper :: Monad m => Parser Char m Char
    [A] symbol :: Monad m => Parser Char m Char
    [A] stringIgnoreCase :: Monad m => String -> Parser Char m String
    [A] string :: Monad m => String -> Parser Char m String
    [A] space :: Monad m => Parser Char m Char
    [A] signed :: (Num a, Monad m) => Parser Char m a -> Parser Char m a
    [A] separator :: Monad m => Parser Char m Char
    [A] punctuation :: Monad m => Parser Char m Char
    [A] printable :: Monad m => Parser Char m Char
    [A] octDigit :: Monad m => Parser Char m Char
    [A] numeric :: Monad m => Parser Char m Char
    [A] mark :: Monad m => Parser Char m Char
    [A] lower :: Monad m => Parser Char m Char
    [A] letter :: Monad m => Parser Char m Char
    [A] latin1 :: Monad m => Parser Char m Char
    [A] hexadecimal :: (Monad m, Integral a, Bits a) => Parser Char m a
    [A] hexDigit :: Monad m => Parser Char m Char
    [A] dropSpace1 :: Monad m => Parser Char m ()
    [A] dropSpace :: Monad m => Parser Char m ()
    [A] digit :: Monad m => Parser Char m Char
    [A] decimal :: (Monad m, Integral a) => Parser Char m a
    [A] charIgnoreCase :: Monad m => Char -> Parser Char m Char
    [A] char :: Monad m => Char -> Parser Char m Char
    [A] asciiUpper :: Monad m => Parser Char m Char
    [A] asciiLower :: Monad m => Parser Char m Char
    [A] ascii :: Monad m => Parser Char m Char
    [A] alphaNum :: Monad m => Parser Char m Char
    [A] alpha :: Monad m => Parser Char m Char
[C] Streamly.FileSystem.Handle
    [D] writeWithBufferOf :: MonadIO m => Int -> Handle -> Fold m Word8 ()
    [A] writeWith :: MonadIO m => Int -> Handle -> Fold m Word8 ()
    [C] writeChunks
        [O] writeChunks :: (MonadIO m, Storable a) => Handle -> Fold m (Array a) ()
        [N] writeChunks :: MonadIO m => Handle -> Fold m (Array a) ()
    [A] readerWith :: MonadIO m => Unfold m (Int, Handle) Word8
    [A] reader :: MonadIO m => Unfold m Handle Word8
    [D] readWithBufferOf :: MonadIO m => Unfold m (Int, Handle) Word8
    [D] readChunksWithBufferOf :: MonadIO m => Unfold m (Int, Handle) (Array Word8)
    [D] readChunks :: MonadIO m => Unfold m Handle (Array Word8)
    [D] read :: MonadIO m => Unfold m Handle Word8
    [C] putChunk
        [O] putChunk :: (MonadIO m, Storable a) => Handle -> Array a -> m ()
        [N] putChunk :: MonadIO m => Handle -> Array a -> m ()
    [A] chunkReaderWith :: MonadIO m => Unfold m (Int, Handle) (Array Word8)
    [A] chunkReader :: MonadIO m => Unfold m Handle (Array Word8)
[A] Streamly.FileSystem.File
    [A] writeWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Fold m Word8 ()
    [A] writeChunks :: (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
    [A] write :: (MonadIO m, MonadCatch m) => FilePath -> Fold m Word8 ()
    [A] withFile :: (MonadIO m, MonadCatch m) => FilePath -> IOMode -> (Handle -> Stream m a) -> Stream m a
    [A] readChunksWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m (Array Word8)
    [A] readChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array Word8)
    [A] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8
[A] Streamly.FileSystem.Dir
    [A] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath)
    [A] read :: MonadIO m => FilePath -> Stream m FilePath
[C] Streamly.Data.Unfold
    [C] take
        [O] take :: Monad m => Int -> Unfold m a b -> Unfold m a b
        [N] take :: Applicative m => Int -> Unfold m a b -> Unfold m a b
    [C] replicateM
        [O] replicateM :: Monad m => Int -> Unfold m (m a) a
        [N] replicateM :: Applicative m => Unfold m (Int, m a) a
    [C] repeatM
        [O] repeatM :: Monad m => Unfold m (m a) a
        [N] repeatM :: Applicative m => Unfold m (m a) a
    [C] many
        [O] many :: Monad m => Unfold m a b -> Unfold m b c -> Unfold m a c
        [N] many :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
    [C] iterateM
        [O] iterateM :: Monad m => (a -> m a) -> Unfold m (m a) a
        [N] iterateM :: Applicative m => (a -> m a) -> Unfold m (m a) a
    [C] fromStream
        [O] fromStream :: (IsStream t, Monad m) => Unfold m (t m a) a
        [N] fromStream :: Applicative m => Unfold m (Stream m a) a
    [C] fromListM
        [O] fromListM :: Monad m => Unfold m [m a] a
        [N] fromListM :: Applicative m => Unfold m [m a] a
    [C] fromList
        [O] fromList :: Monad m => Unfold m [a] a
        [N] fromList :: Applicative m => Unfold m [a] a
    [C] drop
        [O] drop :: Monad m => Int -> Unfold m a b -> Unfold m a b
        [N] drop :: Applicative m => Int -> Unfold m a b -> Unfold m a b
[A] Streamly.Data.StreamK
    [A] StreamK
    [A] zipWithM :: Monad m => (a -> b -> m c) -> StreamK m a -> StreamK m b -> StreamK m c
    [A] zipWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
    [A] uncons :: Applicative m => StreamK m a -> m (Maybe (a, StreamK m a))
    [A] toStream :: Applicative m => StreamK m a -> Stream m a
    [A] sortBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> StreamK m a
    [A] reverse :: StreamK m a -> StreamK m a
    [A] parseChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b)
    [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] nilM :: Applicative m => m b -> StreamK m a
    [A] nil :: StreamK m a
    [A] mergeMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
    [A] mergeBy :: (a -> a -> Ordering) -> StreamK m a -> StreamK m a -> StreamK m a
    [A] interleave :: StreamK m a -> StreamK m a -> StreamK m a
    [A] fromStream :: Monad m => Stream m a -> StreamK m a
    [A] fromPure :: a -> StreamK m a
    [A] fromFoldable :: Foldable f => f a -> StreamK m a
    [A] fromEffect :: Monad m => m a -> StreamK m a
    [A] crossWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c
    [A] consM :: Monad m => m a -> StreamK m a -> StreamK m a
    [A] cons :: a -> StreamK m a -> StreamK m a
    [A] concatMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] concatEffect :: Monad m => m (StreamK m a) -> StreamK m a
    [A] append :: StreamK m a -> StreamK m a -> StreamK m a
[A] Streamly.Data.Stream
    [A] class Enum a => Enumerable a
    [A] Stream
    [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
    [A] zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
    [A] unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a
    [A] unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a
    [A] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] unfold :: Applicative m => Unfold m a b -> a -> Stream m b
    [A] uncons :: Monad m => Stream m a -> m (Maybe (a, Stream m a))
    [A] trace :: Monad m => (a -> m b) -> Stream m a -> Stream m a
    [A] toList :: Monad m => Stream m a -> m [a]
    [A] tap :: Monad m => Fold m a b -> Stream m a -> Stream m a
    [A] takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
    [A] takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
    [A] take :: Applicative m => Int -> Stream m a -> Stream m a
    [A] stripPrefix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a))
    [A] sequence :: Monad m => Stream m (m a) -> Stream m a
    [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b
    [A] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] runStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m (s, a)
    [A] runReaderT :: Monad m => m s -> Stream (ReaderT s m) a -> Stream m a
    [A] reverse :: Monad m => Stream m a -> Stream m a
    [A] replicateM :: Monad m => Int -> m a -> Stream m a
    [A] replicate :: Monad m => Int -> a -> Stream m a
    [A] repeatM :: Monad m => m a -> Stream m a
    [A] repeat :: Monad m => a -> Stream m a
    [A] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] parseMany :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b)
    [A] parse :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b)
    [A] onException :: MonadCatch m => m b -> Stream m a -> Stream m a
    [A] nilM :: Applicative m => m b -> Stream m a
    [A] nil :: Applicative m => Stream m a
    [A] morphInner :: Monad n => (forall x. m x -> n x) -> Stream m a -> Stream n a
    [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] mergeBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b
    [A] mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b
    [A] mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b
    [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => Stream m a -> Stream (t m) a
    [A] iterateM :: Monad m => (a -> m a) -> m a -> Stream m a
    [A] iterate :: Monad m => (a -> a) -> a -> Stream m a
    [A] isSubsequenceOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
    [A] isPrefixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool
    [A] intersperseM_ :: Monad m => m b -> Stream m a -> Stream m a
    [A] intersperseM :: Monad m => m a -> Stream m a -> Stream m a
    [A] intersperse :: Monad m => a -> Stream m a -> Stream m a
    [A] interleave :: Monad m => Stream m a -> Stream m a -> Stream m a
    [A] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
    [A] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
    [A] insertBy :: Monad m => (a -> a -> Ordering) -> a -> Stream m a -> Stream m a
    [A] indexed :: Monad m => Stream m a -> Stream m (Int, a)
    [A] handle :: (MonadCatch m, Exception e) => (e -> Stream m a) -> Stream m a -> Stream m a
    [A] fromPure :: Applicative m => a -> Stream m a
    [A] fromList :: Applicative m => [a] -> Stream m a
    [A] fromEffect :: Applicative m => m a -> Stream m a
    [A] foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b
    [A] foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b
    [A] foldMany :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] foldBreak :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a)
    [A] fold :: Monad m => Fold m a b -> Stream m a -> m b
    [A] finallyIO :: (MonadIO m, MonadCatch m) => IO b -> Stream m a -> Stream m a
    [A] filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
    [A] filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
    [A] eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool
    [A] enumerateTo :: (Monad m, Bounded a, Enumerable a) => a -> Stream m a
    [A] enumerateFromTo :: (Enumerable a, Monad m) => a -> a -> Stream m a
    [A] enumerateFromThenTo :: (Enumerable a, Monad m) => a -> a -> a -> Stream m a
    [A] enumerateFromThen :: (Enumerable a, Monad m) => a -> a -> Stream m a
    [A] enumerateFrom :: (Enumerable a, Monad m) => a -> Stream m a
    [A] enumerate :: (Monad m, Bounded a, Enumerable a) => Stream m a
    [A] dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a
    [A] dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
    [A] drop :: Monad m => Int -> Stream m a -> Stream m a
    [A] delay :: MonadIO m => Double -> Stream m a -> Stream m a
    [A] crossWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
    [A] consM :: Applicative m => m a -> Stream m a -> Stream m a
    [A] cons :: Applicative m => a -> Stream m a -> Stream m a
    [A] concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
    [A] concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
    [A] concatEffect :: Monad m => m (Stream m a) -> Stream m a
    [A] cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering
    [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
    [A] catRights :: Monad m => Stream m (Either a b) -> Stream m b
    [A] catMaybes :: Monad m => Stream m (Maybe a) -> Stream m a
    [A] catLefts :: Monad m => Stream m (Either a b) -> Stream m a
    [A] catEithers :: Monad m => Stream m (Either a a) -> Stream m a
    [A] bracketIO3 :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> IO d) -> (b -> IO e) -> (b -> Stream m a) -> Stream m a
    [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
    [A] before :: Monad m => m b -> Stream m a -> Stream m a
    [A] append :: Monad m => Stream m a -> Stream m a -> Stream m a
    [A] afterIO :: MonadIO m => IO b -> Stream m a -> Stream m a
[A] Streamly.Data.ParserK
    [A] ParserK
    [A] fromPure :: b -> ParserK a m b
    [A] fromParser :: (Monad m, Unbox a) => Parser a m b -> ParserK a m b
    [A] fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK a m b
    [A] fromEffect :: Monad m => m b -> ParserK a m b
    [A] die :: String -> ParserK a m b
[A] Streamly.Data.Parser
    [A] Parser
    [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
    [A] wordBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [A] takeWhile1 :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [A] takeWhile :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [A] takeEQ :: Monad m => Int -> Fold m a b -> Parser a m b
    [A] streamEqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Parser a m ()
    [A] some :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
    [A] satisfy :: Monad m => (a -> Bool) -> Parser a m a
    [A] rmapM :: Monad m => (b -> m c) -> Parser a m b -> Parser a m c
    [A] peek :: Monad m => Parser a m a
    [A] oneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
    [A] one :: Monad m => Parser a m a
    [A] noneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a
    [A] manyTill :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c
    [A] many :: Monad m => Parser a m b -> Fold m b c -> Parser a m c
    [A] lookAhead :: Monad m => Parser a m b -> Parser a m b
    [A] lmapM :: Monad m => (a -> m b) -> Parser b m r -> Parser a m r
    [A] lmap :: (a -> b) -> Parser b m r -> Parser a m r
    [A] listEqBy :: Monad m => (a -> a -> Bool) -> [a] -> Parser a m [a]
    [A] listEq :: (Monad m, Eq a) => [a] -> Parser a m [a]
    [A] groupBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b
    [A] fromPure :: Monad m => b -> Parser a m b
    [A] fromFold :: Monad m => Fold m a b -> Parser a m b
    [A] fromEffect :: Monad m => m b -> Parser a m b
    [A] filter :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
    [A] eof :: Monad m => Parser a m ()
    [A] dropWhile :: Monad m => (a -> Bool) -> Parser a m ()
    [A] die :: Monad m => String -> Parser a m b
    [A] deintercalate :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z
[A] Streamly.Data.MutArray.Generic
    [A] MutArray
    [A] writeN :: MonadIO m => Int -> Fold m a (MutArray a)
    [A] toList :: MonadIO m => MutArray a -> m [a]
    [A] snoc :: MonadIO m => MutArray a -> a -> m (MutArray a)
    [A] reader :: MonadIO m => Unfold m (MutArray a) a
    [A] putIndex :: MonadIO m => Int -> MutArray a -> a -> m ()
    [A] new :: forall m a. MonadIO m => Int -> m (MutArray a)
    [A] modifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
    [A] getIndex :: MonadIO m => Int -> MutArray a -> m a
[A] Streamly.Data.MutArray
    [A] class Unbox a
    [A] MutArray
    [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [A] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
    [A] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
    [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
    [A] toList :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m [a]
    [A] snoc :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
    [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
    [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
    [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a
    [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
    [A] pokeByteIndex :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()
    [A] peekByteIndex :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a
    [A] newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [A] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [A] length :: forall a. Unbox a => MutArray a -> Int
    [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
    [A] fromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
    [A] fromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
    [A] cast :: forall a b. Unbox b => MutArray a -> Maybe (MutArray b)
    [A] asBytes :: MutArray a -> MutArray Word8
[C] Streamly.Data.Fold
    [A] Tee
        [A] [unTee] :: Tee m a b -> Fold m a b
        [A] Tee :: Fold m a b -> Tee m a b
    [D] variance :: (Monad m, Fractional a) => Fold m a a
    [A] uniqBy :: Monad m => (a -> a -> Bool) -> Fold m a (Maybe a)
    [A] topBy :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Int -> Fold m a (MutArray a)
    [A] toSet :: (Monad m, Ord a) => Fold m a (Set a)
    [A] toMapIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
    [A] toMap :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b)
    [A] toIntSet :: Monad m => Fold m Int IntSet
    [A] the :: (Monad m, Eq a) => Fold m a (Maybe a)
    [D] stdDev :: (Monad m, Floating a) => Fold m a a
    [A] splitWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
    [D] serialWith :: Monad m => (a -> b -> c) -> Fold m x a -> Fold m x b -> Fold m x c
    [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Fold m b c -> Fold m a c
    [A] scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [A] postscan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [A] one :: Monad m => Fold m a (Maybe a)
    [A] nubInt :: Monad m => Fold m Int (Maybe Int)
    [A] nub :: (Monad m, Ord a) => Fold m a (Maybe a)
    [A] morphInner :: (forall x. m x -> n x) -> Fold m a b -> Fold n a b
    [A] latest :: Monad m => Fold m a (Maybe a)
    [D] last :: Monad m => Fold m a (Maybe a)
    [D] head :: Monad m => Fold m a (Maybe a)
    [A] groupsOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
    [A] frequency :: (Monad m, Ord a) => Fold m a (Map a Int)
    [A] foldr' :: Monad m => (a -> b -> b) -> b -> Fold m a b
    [D] foldr :: Monad m => (a -> b -> b) -> b -> Fold m a b
    [A] foldlM1' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
    [A] foldl1' :: Monad m => (a -> a -> a) -> Fold m a (Maybe a)
    [A] findM :: Monad m => (a -> m Bool) -> Fold m a (Maybe a)
    [A] findIndices :: Monad m => (a -> Bool) -> Fold m a (Maybe Int)
    [A] elemIndices :: (Monad m, Eq a) => a -> Fold m a (Maybe Int)
    [A] duplicate :: Monad m => Fold m a b -> Fold m a (Fold m a b)
    [A] drive :: Monad m => Stream m a -> Fold m a b -> m b
    [A] drainMapM :: Monad m => (a -> m b) -> Fold m a ()
    [D] drainBy :: Monad m => (a -> m b) -> Fold m a ()
    [A] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
    [A] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
    [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
    [A] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
    [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Fold m a (Maybe a)
    [A] countDistinctInt :: Monad m => Fold m Int Int
    [A] countDistinct :: (Monad m, Ord a) => Fold m a Int
    [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
    [A] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
    [D] chunksOf :: Monad m => Int -> Fold m a b -> Fold m b c -> Fold m a c
    [A] catRights :: Monad m => Fold m b c -> Fold m (Either a b) c
    [A] catLefts :: Monad m => Fold m a c -> Fold m (Either a b) c
    [A] catEithers :: Fold m a b -> Fold m (Either a a) b
    [A] addStream :: Monad m => Stream m a -> Fold m a b -> m (Fold m a b)
    [A] addOne :: Monad m => a -> Fold m a b -> m (Fold m a b)
[A] Streamly.Data.Array.Generic
    [A] Array
    [A] writeN :: MonadIO m => Int -> Fold m a (Array a)
    [A] write :: MonadIO m => Fold m a (Array a)
    [A] reader :: Monad m => Unfold m (Array a) a
    [A] readRev :: Monad m => Array a -> Stream m a
    [A] read :: MonadIO m => Array a -> Stream m a
    [A] length :: Array a -> Int
    [A] fromListN :: Int -> [a] -> Array a
    [A] fromList :: [a] -> Array a
[A] Streamly.Data.Array
    [A] class Unbox a
    [A] Array
    [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [A] writeLastN :: (Storable a, Unbox a, MonadIO m) => Int -> Fold m a (Array a)
    [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
    [A] toList :: Unbox a => Array a -> [a]
    [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int
    [A] readerRev :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
    [A] reader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
    [A] pokeByteIndex :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutableByteArray -> a -> IO ()
    [A] peekByteIndex :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutableByteArray -> IO a
    [A] length :: Unbox a => Array a -> Int
    [A] getIndex :: forall a. Unbox a => Int -> Array a -> Maybe a
    [A] fromListN :: Unbox a => Int -> [a] -> Array a
    [A] fromList :: Unbox a => [a] -> Array a
    [A] cast :: forall a b. Unbox b => Array a -> Maybe (Array b)
    [A] asBytes :: Array a -> Array Word8
[C] Streamly.Console.Stdio
    [A] reader :: MonadIO m => Unfold m () Word8
    [D] readChunks :: MonadIO m => Unfold m () (Array Word8)
    [D] read :: MonadIO m => Unfold m () Word8
    [A] chunkReader :: MonadIO m => Unfold m () (Array Word8)