---------------------------------
API Annotations
---------------------------------

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

---------------------------------
API diff
---------------------------------

[C] Streamly.Unicode.Stream
    [A] encodeUtf16le' :: Monad m => Stream m Char -> Stream m Word16
    [A] encodeUtf16le :: Monad m => Stream m Char -> Stream m Word16
    [A] decodeUtf16le' :: Monad m => Stream m Word16 -> Stream m Char
    [A] decodeUtf16le :: Monad m => Stream m Word16 -> Stream m Char
[A] Streamly.FileSystem.Path
    [A] EqCfg
    [A] type Path = PosixPath
    [A] type OsWord = Word8
    [A] validatePath :: MonadThrow m => Array OsWord -> m ()
    [A] unsafeJoin :: Path -> Path -> Path
    [A] toString :: Path -> [Char]
    [A] toArray :: Path -> Array OsWord
    [A] takeFileName :: Path -> Maybe Path
    [A] takeFileBase :: Path -> Maybe Path
    [A] takeExtension :: Path -> Maybe Path
    [A] takeDirectory :: Path -> Maybe Path
    [A] splitRoot :: Path -> Maybe (Path, Maybe Path)
    [A] splitPath :: Monad m => Path -> Stream m Path
    [A] splitFile :: Path -> Maybe (Maybe Path, Path)
    [A] splitExtension :: Path -> Maybe (Path, Path)
    [A] pathE :: String -> Q Exp
    [A] path :: QuasiQuoter
    [A] joinStr :: Path -> [Char] -> Path
    [A] join :: Path -> Path -> Path
    [A] isUnrooted :: Path -> Bool
    [A] isRooted :: Path -> Bool
    [A] ignoreTrailingSeparators :: Bool -> EqCfg -> EqCfg
    [A] ignoreCase :: Bool -> EqCfg -> EqCfg
    [A] fromString_ :: [Char] -> Path
    [A] fromString :: MonadThrow m => [Char] -> m Path
    [A] fromArray :: MonadThrow m => Array OsWord -> m Path
    [A] eqPath :: (EqCfg -> EqCfg) -> Path -> Path -> Bool
    [A] dropExtension :: Path -> Path
    [A] allowRelativeEquality :: Bool -> EqCfg -> EqCfg
[C] Streamly.FileSystem.Handle
    [C] writeChunks
        [O] writeChunks :: MonadIO m => Handle -> Fold m (Array a) ()
        [N] writeChunks :: forall m (a :: Type). MonadIO m => Handle -> Fold m (Array a) ()
    [C] putChunk
        [O] putChunk :: MonadIO m => Handle -> Array a -> m ()
        [N] putChunk :: forall m (a :: Type). MonadIO m => Handle -> Array a -> m ()
[A] Streamly.FileSystem.FileIO
    [A] writeWith :: (MonadIO m, MonadCatch m) => Int -> Path -> Fold m Word8 ()
    [A] writeChunks :: (MonadIO m, MonadCatch m) => Path -> Fold m (Array a) ()
    [A] write :: (MonadIO m, MonadCatch m) => Path -> Fold m Word8 ()
    [A] withFile :: (MonadIO m, MonadCatch m) => Path -> IOMode -> (Handle -> Stream m a) -> Stream m a
    [A] readChunksWith :: (MonadIO m, MonadCatch m) => Int -> Path -> Stream m (Array Word8)
    [A] readChunks :: (MonadIO m, MonadCatch m) => Path -> Stream m (Array Word8)
    [A] read :: (MonadIO m, MonadCatch m) => Path -> Stream m Word8
[D] Streamly.FileSystem.File
    [C] writeChunks
        [O] writeChunks :: (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
        [N] writeChunks :: forall m (a :: Type). (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
[A] Streamly.FileSystem.DirIO
    [A] ReadOptions
    [A] readEither :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Path -> Stream m (Either Path Path)
    [A] read :: (MonadIO m, MonadCatch m) => Path -> Stream m Path
    [A] ignoreSymlinkLoops :: Bool -> ReadOptions -> ReadOptions
    [A] ignoreMissing :: Bool -> ReadOptions -> ReadOptions
    [A] ignoreInaccessible :: Bool -> ReadOptions -> ReadOptions
    [A] followSymlinks :: Bool -> ReadOptions -> ReadOptions
[D] Streamly.FileSystem.Dir
[C] Streamly.Data.Unfold
    [A] unfoldEach :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
    [D] many :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
    [A] carry :: Functor m => Unfold m a b -> Unfold m a (a, b)
[C] Streamly.Data.StreamK
    [A] toParserK :: Monad m => Parser a m b -> ParserK a m b
    [A] toList :: Monad m => StreamK m a -> m [a]
    [A] parsePos :: Monad m => ParserK a m b -> StreamK m a -> m (Either ParseErrorPos b)
    [D] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [A] parseBreakPos :: forall m a b. Monad m => ParserK a m b -> StreamK m a -> m (Either ParseErrorPos b, StreamK m a)
    [D] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] filter :: (a -> Bool) -> StreamK m a -> StreamK m a
    [A] fairConcatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] fairConcatForM :: Monad m => StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] fairConcatFor :: StreamK m a -> (a -> StreamK m b) -> StreamK m b
    [A] concatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] concatForM :: Monad m => StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] concatFor :: StreamK m a -> (a -> StreamK m b) -> StreamK m b
    [A] bfsConcatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] bfsConcatForM :: Monad m => StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] bfsConcatFor :: StreamK m a -> (a -> StreamK m b) -> StreamK m b
[C] Streamly.Data.Stream
    [A] unionBy :: MonadIO m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [D] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] unfoldEachSepBySeq :: Monad m => b -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEachEndBySeq :: Monad m => b -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] splitSepBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
    [A] splitSepBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [D] splitOn :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
    [A] splitEndBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [A] splitEndBySeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [A] scanl :: Monad m => Scanl m a b -> Stream m a -> Stream m b
    [D] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b
    [D] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] postscanl :: Monad m => Scanl m a b -> Stream m a -> Stream m b
    [D] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] parsePos :: Monad m => Parser a m b -> Stream m a -> m (Either ParseErrorPos b)
    [A] parseBreakPos :: Monad m => Parser a m b -> Stream m a -> m (Either ParseErrorPos b, Stream m a)
    [A] parseBreak :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a)
    [A] isInfixOf :: (MonadIO m, Eq a, Enum a, Unbox a) => Stream m a -> Stream m a -> m Bool
    [D] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
    [D] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
    [A] finallyIO'' :: (MonadIO m, MonadCatch m) => AcquireIO -> IO b -> Stream m a -> Stream m a
    [A] finallyIO' :: MonadIO m => AcquireIO -> IO b -> Stream m a -> Stream m a
    [A] fairUnfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] fairCross :: Monad m => Stream m a -> Stream m b -> Stream m (a, b)
    [A] fairConcatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
    [A] fairConcatForM :: Monad m => Stream m a -> (a -> m (Stream m b)) -> Stream m b
    [A] fairConcatFor :: Monad m => Stream m a -> (a -> Stream m b) -> Stream m b
    [A] cross :: Monad m => Stream m a -> Stream m b -> Stream m (a, b)
    [A] concatForM :: Monad m => Stream m a -> (a -> m (Stream m b)) -> Stream m b
    [A] concatFor :: Monad m => Stream m a -> (a -> Stream m b) -> Stream m b
    [D] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
    [A] bracketIO'' :: (MonadIO m, MonadCatch m) => AcquireIO -> IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
    [A] bracketIO' :: MonadIO m => AcquireIO -> IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
    [A] bfsUnfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
[A] Streamly.Data.Scanl
    [A] Scanl
    [A] unzip :: Monad m => Scanl m a x -> Scanl m b y -> Scanl m (a, b) (x, y)
    [A] uniqBy :: Monad m => (a -> a -> Bool) -> Scanl m a (Maybe a)
    [A] topBy :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Int -> Scanl m a (MutArray a)
    [A] toSet :: (Monad m, Ord a) => Scanl m a (Set a)
    [A] toListRev :: Monad m => Scanl m a [a]
    [A] toList :: Monad m => Scanl m a [a]
    [A] toIntSet :: Monad m => Scanl m Int IntSet
    [A] the :: (Monad m, Eq a) => Scanl m a (Maybe a)
    [A] teeWith :: Monad m => (b -> c -> d) -> Scanl m a b -> Scanl m a c -> Scanl m a d
    [A] tee :: Monad m => Scanl m a b -> Scanl m a c -> Scanl m a (b, c)
    [A] takeEndBy_ :: Monad m => (a -> Bool) -> Scanl m a b -> Scanl m a b
    [A] takeEndBy :: Monad m => (a -> Bool) -> Scanl m a b -> Scanl m a b
    [A] take :: Monad m => Int -> Scanl m a b -> Scanl m a b
    [A] sum :: (Monad m, Num a) => Scanl m a a
    [A] sconcat :: (Monad m, Semigroup a) => a -> Scanl m a a
    [A] scanl :: Monad m => Scanl m a b -> Scanl m b c -> Scanl m a c
    [A] rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Scanl m a Int64
    [A] rollingHash :: (Monad m, Enum a) => Scanl m a Int64
    [A] rmapM :: Monad m => (b -> m c) -> Scanl m a b -> Scanl m a c
    [A] product :: (Monad m, Num a, Eq a) => Scanl m a a
    [A] postscanlMaybe :: Monad m => Scanl m a (Maybe b) -> Scanl m b c -> Scanl m a c
    [A] postscanl :: Monad m => Scanl m a b -> Scanl m b c -> Scanl m a c
    [A] partition :: Monad m => Scanl m b x -> Scanl m c x -> Scanl m (Either b c) x
    [A] nubInt :: Monad m => Scanl m Int (Maybe Int)
    [A] nub :: (Monad m, Ord a) => Scanl m a (Maybe a)
    [A] morphInner :: (forall x. m x -> n x) -> Scanl m a b -> Scanl n a b
    [A] mkScanr :: Monad m => (a -> b -> b) -> b -> Scanl m a b
    [A] mkScanlM :: Monad m => (b -> a -> m b) -> m b -> Scanl m a b
    [A] mkScanl1M :: Monad m => (a -> a -> m a) -> Scanl m a (Maybe a)
    [A] mkScanl1 :: Monad m => (a -> a -> a) -> Scanl m a (Maybe a)
    [A] mkScanl :: Monad m => (b -> a -> b) -> b -> Scanl m a b
    [A] minimumBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe a)
    [A] minimum :: (Monad m, Ord a) => Scanl m a (Maybe a)
    [A] mean :: (Monad m, Fractional a) => Scanl m a a
    [A] mconcat :: (Monad m, Monoid a) => Scanl m a a
    [A] maximumBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe a)
    [A] maximum :: (Monad m, Ord a) => Scanl m a (Maybe a)
    [A] mapMaybe :: Monad m => (a -> Maybe b) -> Scanl m b r -> Scanl m a r
    [A] lmapM :: Monad m => (a -> m b) -> Scanl m b r -> Scanl m a r
    [A] lmap :: (a -> b) -> Scanl m b r -> Scanl m a r
    [A] length :: Monad m => Scanl m a Int
    [A] latest :: Monad m => Scanl m a (Maybe a)
    [A] foldMapM :: (Monad m, Monoid b) => (a -> m b) -> Scanl m a b
    [A] foldMap :: (Monad m, Monoid b) => (a -> b) -> Scanl m a b
    [A] findIndices :: Monad m => (a -> Bool) -> Scanl m a (Maybe Int)
    [A] filterM :: Monad m => (a -> m Bool) -> Scanl m a r -> Scanl m a r
    [A] filter :: Monad m => (a -> Bool) -> Scanl m a r -> Scanl m a r
    [A] elemIndices :: (Monad m, Eq a) => a -> Scanl m a (Maybe Int)
    [A] drain :: Monad m => Scanl m a ()
    [A] distribute :: Monad m => [Scanl m a b] -> Scanl m a [b]
    [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (k -> m (Maybe (Scanl m a b))) -> Scanl m a (Maybe (k, b))
    [A] demux :: (Monad m, Ord k) => (a -> k) -> (k -> m (Maybe (Scanl m a b))) -> Scanl m a (Maybe (k, b))
    [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Scanl m a (Maybe a)
    [A] countDistinctInt :: Monad m => Scanl m Int Int
    [A] countDistinct :: (Monad m, Ord a) => Scanl m a Int
    [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Scanl m a b -> Scanl m a (Maybe (k, b))
    [A] classify :: (MonadIO m, Ord k) => (a -> k) -> Scanl m a b -> Scanl m a (Maybe (k, b))
    [A] catRights :: Monad m => Scanl m b c -> Scanl m (Either a b) c
    [A] catMaybes :: Monad m => Scanl m a b -> Scanl m (Maybe a) b
    [A] catLefts :: Monad m => Scanl m a c -> Scanl m (Either a b) c
    [A] catEithers :: Scanl m a b -> Scanl m (Either a a) b
[A] Streamly.Data.RingArray
    [A] RingArray
    [A] unsafeGetIndex :: forall m a. (MonadIO m, Unbox a) => Int -> RingArray a -> m a
    [A] unsafeGetHead :: (MonadIO m, Unbox a) => RingArray a -> m a
    [A] toMutArray :: (MonadIO m, Unbox a) => RingArray a -> m (MutArray a)
    [A] toList :: (MonadIO m, Unbox a) => RingArray a -> m [a]
    [A] scanRingsOf :: forall m a. (MonadIO m, Unbox a) => Int -> Scanl m a (RingArray a)
    [A] ringsOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (RingArray a)
    [A] replace_ :: forall m a. (MonadIO m, Unbox a) => RingArray a -> a -> m (RingArray a)
    [A] replace :: forall m a. (MonadIO m, Unbox a) => RingArray a -> a -> m (RingArray a, a)
    [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (RingArray a) a
    [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (RingArray a) a
    [A] readRev :: forall m a. (MonadIO m, Unbox a) => RingArray a -> Stream m a
    [A] read :: forall m a. (MonadIO m, Unbox a) => RingArray a -> Stream m a
    [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> RingArray a -> a -> m ()
    [A] moveReverse :: forall a. Unbox a => RingArray a -> RingArray a
    [A] moveForward :: forall a. Unbox a => RingArray a -> RingArray a
    [A] modifyIndex :: Int -> RingArray a -> (a -> (a, b)) -> m b
    [A] length :: forall a. Unbox a => RingArray a -> Int
    [A] insert :: RingArray a -> a -> m (RingArray a)
    [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> RingArray a -> m (Maybe a)
    [A] fold :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> RingArray a -> m b
    [A] eqArrayN :: RingArray a -> Array a -> Int -> IO Bool
    [A] eqArray :: RingArray a -> Array a -> IO Bool
    [A] createOfLast :: (Unbox a, MonadIO m) => Int -> Fold m a (RingArray a)
    [A] castMutArrayWith :: forall a. Unbox a => Int -> MutArray a -> Maybe (RingArray a)
    [A] castMutArray :: forall a. Unbox a => MutArray a -> Maybe (RingArray a)
    [A] cast :: forall a b. Unbox b => RingArray a -> Maybe (RingArray b)
    [A] byteLength :: RingArray a -> Int
    [A] asMutArray :: RingArray a -> (MutArray a, Int)
    [A] asBytes :: RingArray a -> RingArray Word8
[C] Streamly.Data.ParserK
    [D] adaptCG :: Monad m => Parser a m b -> ParserK (Array a) m b
    [D] adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
    [D] adapt :: Monad m => Parser a m b -> ParserK a m b
[C] Streamly.Data.Parser
    [A] ParseErrorPos
        [A] ParseErrorPos :: Int -> String -> ParseErrorPos
    [A] ParseError
        [A] ParseError :: String -> ParseError
[C] Streamly.Data.MutByteArray
    [D] pinnedNew :: Int -> IO MutByteArray
[C] Streamly.Data.MutArray.Generic
    [D] writeN :: MonadIO m => Int -> Fold m a (MutArray a)
    [D] write :: MonadIO m => Fold m a (MutArray a)
    [A] unsafePutIndex :: forall m a. MonadIO m => Int -> MutArray a -> a -> m ()
    [A] unsafeModifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
    [A] unsafeGetIndex :: MonadIO m => Int -> MutArray a -> m a
    [D] putIndexUnsafe :: forall m a. MonadIO m => Int -> MutArray a -> a -> m ()
    [D] new :: MonadIO m => Int -> m (MutArray a)
    [D] modifyIndexUnsafe :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
    [D] getIndexUnsafe :: MonadIO m => Int -> MutArray a -> m a
    [A] chunksOf :: forall m a. MonadIO m => Int -> Stream m a -> Stream m (MutArray a)
[C] Streamly.Data.MutArray
    [D] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [D] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
    [D] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
    [D] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
    [A] unsafePutIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
    [A] unsafeModifyIndex :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
    [A] unsafeGetIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
    [D] putIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
    [D] pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [D] pinnedEmptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [D] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [D] modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
    [D] getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
    [A] emptyOf' :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
    [D] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
    [A] append2 :: (MonadIO m, Unbox a) => MutArray a -> Fold m a (MutArray a)
    [D] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
[C] Streamly.Data.Fold
    [A] takeEndBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Fold m a b
    [A] takeEndBySeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Fold m a b
    [A] scanl :: Monad m => Scanl m a b -> Fold m b c -> Fold m a c
    [D] scanMaybe :: Monad m => Fold m a (Maybe b) -> Fold m b c -> Fold m a c
    [D] scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [A] postscanl :: Monad m => Scanl m a b -> Fold m b c -> Fold m a c
    [D] postscan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [A] foldtM' :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> Fold m a b
    [D] foldlM1' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
    [A] foldl1M' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
    [A] demuxerToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (k -> m (Maybe (Fold m a b))) -> Fold m a (Map k b)
    [A] demuxerToMap :: (Monad m, Ord k) => (a -> k) -> (k -> m (Maybe (Fold m a b))) -> Fold m a (Map k b)
    [D] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
    [D] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
    [D] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
    [D] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
    [D] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
    [D] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
[C] Streamly.Data.Array.Generic
    [D] writeN :: MonadIO m => Int -> Fold m a (Array a)
    [D] write :: MonadIO m => Fold m a (Array a)
    [A] toParserK :: Monad m => Parser a m b -> ParserK (Array a) m b
    [A] parsePos :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b)
    [A] parseBreakPos :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b, StreamK m (Array a))
    [A] parseBreak :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] parse :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [A] chunksOf :: forall m a. MonadIO m => Int -> Stream m a -> Stream m (Array a)
[C] Streamly.Data.Array
    [D] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [D] writeLastN :: (Unbox a, MonadIO m) => Int -> Fold m a (Array a)
    [D] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
    [A] toParserK :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
    [A] serialize' :: Serialize a => a -> Array Word8
    [D] pinnedSerialize :: Serialize a => a -> Array Word8
    [A] parsePos :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b)
    [A] parseBreakPos :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b, StreamK m (Array a))
    [A] parseBreak :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] parse :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [C] deserialize
        [O] deserialize :: Serialize a => Array Word8 -> a
        [N] deserialize :: Serialize a => Array Word8 -> (a, Array Word8)
    [A] createOfLast :: (Unbox a, MonadIO m) => Int -> Fold m a (Array a)
    [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
[A] Streamly.Control.Exception
    [A] AcquireIO
    [A] withAcquireIO :: (MonadIO m, MonadMask m) => (AcquireIO -> m a) -> m a
    [A] register :: AcquireIO -> IO () -> IO ()
    [A] hook :: AcquireIO -> IO () -> IO (IO ())
    [A] acquire :: AcquireIO -> IO b -> (b -> IO c) -> IO (b, IO ())
[C] Streamly.Console.Stdio
    [A] readChunks :: MonadIO m => Stream m (Array Word8)
    [A] readChars :: MonadIO m => Stream m Char
    [A] read :: MonadIO m => Stream m Word8
    [A] putChunks :: MonadIO m => Stream m (Array Word8) -> m ()

---------------------------------
Internal API diff
---------------------------------

[C] Streamly.Internal.Unicode.Stream
    [A] swapByteOrder :: Word16 -> Word16
    [A] mkEvenW8Chunks :: Monad m => Stream m (Array Word8) -> Stream m (Array Word8)
    [C] encodeUtf16le'
        [O] encodeUtf16le' :: Stream m Char -> Stream m Word16
        [N] encodeUtf16le' :: Monad m => Stream m Char -> Stream m Word16
    [A] encodeUtf16le :: Monad m => Stream m Char -> Stream m Word16
    [C] decodeUtf16le'
        [O] decodeUtf16le' :: Stream m Word16 -> Stream m Char
        [N] decodeUtf16le' :: Monad m => Stream m Word16 -> Stream m Char
    [A] decodeUtf16le :: Monad m => Stream m Word16 -> Stream m Char
[A] Streamly.Internal.FileSystem.WindowsPath.SegNode
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Seg.Unrooted (Streamly.Internal.FileSystem.WindowsPath.Node.File Streamly.Internal.FileSystem.WindowsPath.WindowsPath))
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Seg.Unrooted (Streamly.Internal.FileSystem.WindowsPath.Node.Dir Streamly.Internal.FileSystem.WindowsPath.WindowsPath))
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Seg.Rooted (Streamly.Internal.FileSystem.WindowsPath.Node.File Streamly.Internal.FileSystem.WindowsPath.WindowsPath))
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Seg.Rooted (Streamly.Internal.FileSystem.WindowsPath.Node.Dir Streamly.Internal.FileSystem.WindowsPath.WindowsPath))
    [A] urfileE :: String -> Q Exp
    [A] urfile :: QuasiQuoter
    [A] urdirE :: String -> Q Exp
    [A] urdir :: QuasiQuoter
    [A] rtfileE :: String -> Q Exp
    [A] rtfile :: QuasiQuoter
    [A] rtdirE :: String -> Q Exp
    [A] rtdir :: QuasiQuoter
    [A] join :: (IsPath WindowsPath (a (Dir WindowsPath)), IsPath WindowsPath (b WindowsPath), IsPath WindowsPath (a (b WindowsPath))) => a (Dir WindowsPath) -> Unrooted (b WindowsPath) -> a (b WindowsPath)
[A] Streamly.Internal.FileSystem.WindowsPath.Seg
    [A] class IsSeg a
    [A] Streamly.Internal.FileSystem.WindowsPath.Seg.IsSeg
        [A] instance Streamly.Internal.FileSystem.WindowsPath.Seg.IsSeg (Streamly.Internal.FileSystem.WindowsPath.Seg.Unrooted a)
        [A] instance Streamly.Internal.FileSystem.WindowsPath.Seg.IsSeg (Streamly.Internal.FileSystem.WindowsPath.Seg.Rooted a)
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Seg.Unrooted Streamly.Internal.FileSystem.WindowsPath.WindowsPath)
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Seg.Rooted Streamly.Internal.FileSystem.WindowsPath.WindowsPath)
    [A] Unrooted
        [A] Unrooted :: a -> Unrooted a
    [A] Rooted
        [A] Rooted :: a -> Rooted a
    [A] urE :: String -> Q Exp
    [A] ur :: QuasiQuoter
    [A] rtE :: String -> Q Exp
    [A] rt :: QuasiQuoter
    [A] join :: (IsSeg (a WindowsPath), IsPath WindowsPath (a WindowsPath)) => a WindowsPath -> Unrooted WindowsPath -> a WindowsPath
[A] Streamly.Internal.FileSystem.WindowsPath.Node
    [A] class IsNode a
    [A] Streamly.Internal.FileSystem.WindowsPath.Node.IsNode
        [A] instance Streamly.Internal.FileSystem.WindowsPath.Node.IsNode (Streamly.Internal.FileSystem.WindowsPath.Node.File a)
        [A] instance Streamly.Internal.FileSystem.WindowsPath.Node.IsNode (Streamly.Internal.FileSystem.WindowsPath.Node.Dir a)
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Node.File Streamly.Internal.FileSystem.WindowsPath.WindowsPath)
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath (Streamly.Internal.FileSystem.WindowsPath.Node.Dir Streamly.Internal.FileSystem.WindowsPath.WindowsPath)
    [A] File
        [A] File :: a -> File a
    [A] Dir
        [A] Dir :: a -> Dir a
    [A] join :: (IsPath WindowsPath (a WindowsPath), IsNode (a WindowsPath)) => Dir WindowsPath -> a WindowsPath -> a WindowsPath
    [A] fileE :: String -> Q Exp
    [A] file :: QuasiQuoter
    [A] dirE :: String -> Q Exp
    [A] dir :: QuasiQuoter
[A] Streamly.Internal.FileSystem.WindowsPath
    [A] class IsPath a b
    [A] EqCfg
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath Streamly.Internal.FileSystem.WindowsPath.WindowsPath
    [A] WindowsPath
        [A] WindowsPath :: Array Word16 -> WindowsPath
    [A] wordToChar :: Word16 -> Char
    [A] validatePath' :: MonadThrow m => Array Word16 -> m ()
    [A] validatePath :: MonadThrow m => Array Word16 -> m ()
    [A] unsafeJoinPaths :: [WindowsPath] -> WindowsPath
    [A] unsafeJoin :: WindowsPath -> WindowsPath -> WindowsPath
    [A] unsafeFromString :: [Char] -> WindowsPath
    [A] unsafeFromPath :: IsPath a b => a -> b
    [A] unsafeFromArray :: Array Word16 -> WindowsPath
    [A] toString_ :: WindowsPath -> [Char]
    [A] toString :: WindowsPath -> [Char]
    [A] toPath :: IsPath a b => b -> a
    [A] toChars_ :: Monad m => WindowsPath -> Stream m Char
    [A] toChars :: Monad m => WindowsPath -> Stream m Char
    [A] toArray :: WindowsPath -> Array Word16
    [A] takeFileName :: WindowsPath -> Maybe WindowsPath
    [A] takeFileBase :: WindowsPath -> Maybe WindowsPath
    [A] takeExtension :: WindowsPath -> Maybe WindowsPath
    [A] takeDirectory :: WindowsPath -> Maybe WindowsPath
    [A] splitRoot :: WindowsPath -> Maybe (WindowsPath, Maybe WindowsPath)
    [A] splitPath_ :: Monad m => WindowsPath -> Stream m WindowsPath
    [A] splitPath :: Monad m => WindowsPath -> Stream m WindowsPath
    [A] splitLast :: WindowsPath -> (Maybe WindowsPath, WindowsPath)
    [A] splitFirst :: WindowsPath -> (WindowsPath, Maybe WindowsPath)
    [A] splitFile :: WindowsPath -> Maybe (Maybe WindowsPath, WindowsPath)
    [A] splitExtension :: WindowsPath -> Maybe (WindowsPath, WindowsPath)
    [A] showArray :: WindowsPath -> [Char]
    [A] separator :: Word16
    [A] replaceExtension :: WindowsPath -> WindowsPath -> WindowsPath
    [A] readArray :: [Char] -> WindowsPath
    [A] pathE :: String -> Q Exp
    [A] path :: QuasiQuoter
    [A] normalize :: EqCfg -> WindowsPath -> WindowsPath
    [A] joinStr :: WindowsPath -> [Char] -> WindowsPath
    [A] joinDir :: WindowsPath -> WindowsPath -> WindowsPath
    [A] join :: WindowsPath -> WindowsPath -> WindowsPath
    [A] isValidPath' :: Array Word16 -> Bool
    [A] isValidPath :: Array Word16 -> Bool
    [A] isUnrooted :: WindowsPath -> Bool
    [A] isSeparator :: Word16 -> Bool
    [A] isRooted :: WindowsPath -> Bool
    [A] ignoreTrailingSeparators :: Bool -> EqCfg -> EqCfg
    [A] ignoreCase :: Bool -> EqCfg -> EqCfg
    [A] hasTrailingSeparator :: WindowsPath -> Bool
    [A] fromString_ :: [Char] -> WindowsPath
    [A] fromString :: MonadThrow m => [Char] -> m WindowsPath
    [A] fromPath :: (IsPath a b, MonadThrow m) => a -> m b
    [A] fromChars :: MonadThrow m => Stream Identity Char -> m WindowsPath
    [A] fromArray :: MonadThrow m => Array Word16 -> m WindowsPath
    [A] extSeparator :: Word16
    [A] eqPathBytes :: WindowsPath -> WindowsPath -> Bool
    [A] eqPath :: (EqCfg -> EqCfg) -> WindowsPath -> WindowsPath -> Bool
    [A] encodeString :: [Char] -> Array Word16
    [A] dropTrailingSeparators :: WindowsPath -> WindowsPath
    [A] dropExtension :: WindowsPath -> WindowsPath
    [A] charToWord :: Char -> Word16
    [A] asCWString :: WindowsPath -> (CWString -> IO a) -> IO a
    [A] allowRelativeEquality :: Bool -> EqCfg -> EqCfg
    [A] addTrailingSeparator :: WindowsPath -> WindowsPath
    [A] addExtension :: WindowsPath -> WindowsPath -> WindowsPath
    [A] adapt :: (MonadThrow m, IsPath WindowsPath a, IsPath WindowsPath b) => a -> m b
[A] Streamly.Internal.FileSystem.Windows.ReadDir
[A] Streamly.Internal.FileSystem.Windows.File
[A] Streamly.Internal.FileSystem.PosixPath.SegNode
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Seg.Unrooted (Streamly.Internal.FileSystem.PosixPath.Node.File Streamly.Internal.FileSystem.PosixPath.PosixPath))
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Seg.Unrooted (Streamly.Internal.FileSystem.PosixPath.Node.Dir Streamly.Internal.FileSystem.PosixPath.PosixPath))
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Seg.Rooted (Streamly.Internal.FileSystem.PosixPath.Node.File Streamly.Internal.FileSystem.PosixPath.PosixPath))
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Seg.Rooted (Streamly.Internal.FileSystem.PosixPath.Node.Dir Streamly.Internal.FileSystem.PosixPath.PosixPath))
    [A] urfileE :: String -> Q Exp
    [A] urfile :: QuasiQuoter
    [A] urdirE :: String -> Q Exp
    [A] urdir :: QuasiQuoter
    [A] rtfileE :: String -> Q Exp
    [A] rtfile :: QuasiQuoter
    [A] rtdirE :: String -> Q Exp
    [A] rtdir :: QuasiQuoter
    [A] join :: (IsPath PosixPath (a (Dir PosixPath)), IsPath PosixPath (b PosixPath), IsPath PosixPath (a (b PosixPath))) => a (Dir PosixPath) -> Unrooted (b PosixPath) -> a (b PosixPath)
[A] Streamly.Internal.FileSystem.PosixPath.Seg
    [A] class IsSeg a
    [A] Streamly.Internal.FileSystem.PosixPath.Seg.IsSeg
        [A] instance Streamly.Internal.FileSystem.PosixPath.Seg.IsSeg (Streamly.Internal.FileSystem.PosixPath.Seg.Unrooted a)
        [A] instance Streamly.Internal.FileSystem.PosixPath.Seg.IsSeg (Streamly.Internal.FileSystem.PosixPath.Seg.Rooted a)
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Seg.Unrooted Streamly.Internal.FileSystem.PosixPath.PosixPath)
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Seg.Rooted Streamly.Internal.FileSystem.PosixPath.PosixPath)
    [A] Unrooted
        [A] Unrooted :: a -> Unrooted a
    [A] Rooted
        [A] Rooted :: a -> Rooted a
    [A] urE :: String -> Q Exp
    [A] ur :: QuasiQuoter
    [A] rtE :: String -> Q Exp
    [A] rt :: QuasiQuoter
    [A] join :: (IsSeg (a PosixPath), IsPath PosixPath (a PosixPath)) => a PosixPath -> Unrooted PosixPath -> a PosixPath
[A] Streamly.Internal.FileSystem.PosixPath.Node
    [A] class IsNode a
    [A] Streamly.Internal.FileSystem.PosixPath.Node.IsNode
        [A] instance Streamly.Internal.FileSystem.PosixPath.Node.IsNode (Streamly.Internal.FileSystem.PosixPath.Node.File a)
        [A] instance Streamly.Internal.FileSystem.PosixPath.Node.IsNode (Streamly.Internal.FileSystem.PosixPath.Node.Dir a)
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Node.File Streamly.Internal.FileSystem.PosixPath.PosixPath)
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath (Streamly.Internal.FileSystem.PosixPath.Node.Dir Streamly.Internal.FileSystem.PosixPath.PosixPath)
    [A] File
        [A] File :: a -> File a
    [A] Dir
        [A] Dir :: a -> Dir a
    [A] join :: (IsPath PosixPath (a PosixPath), IsNode (a PosixPath)) => Dir PosixPath -> a PosixPath -> a PosixPath
    [A] fileE :: String -> Q Exp
    [A] file :: QuasiQuoter
    [A] dirE :: String -> Q Exp
    [A] dir :: QuasiQuoter
[A] Streamly.Internal.FileSystem.PosixPath
    [A] class IsPath a b
    [A] EqCfg
    [A] Streamly.Internal.Data.Path.IsPath
        [A] instance Streamly.Internal.Data.Path.IsPath Streamly.Internal.FileSystem.PosixPath.PosixPath Streamly.Internal.FileSystem.PosixPath.PosixPath
    [A] PosixPath
        [A] PosixPath :: Array Word8 -> PosixPath
    [A] wordToChar :: Word8 -> Char
    [A] validatePath :: MonadThrow m => Array Word8 -> m ()
    [A] unsafeJoinPaths :: [PosixPath] -> PosixPath
    [A] unsafeJoin :: PosixPath -> PosixPath -> PosixPath
    [A] unsafeFromString :: [Char] -> PosixPath
    [A] unsafeFromPath :: IsPath a b => a -> b
    [A] unsafeFromArray :: Array Word8 -> PosixPath
    [A] toString_ :: PosixPath -> [Char]
    [A] toString :: PosixPath -> [Char]
    [A] toPath :: IsPath a b => b -> a
    [A] toChars_ :: Monad m => PosixPath -> Stream m Char
    [A] toChars :: Monad m => PosixPath -> Stream m Char
    [A] toArray :: PosixPath -> Array Word8
    [A] takeFileName :: PosixPath -> Maybe PosixPath
    [A] takeFileBase :: PosixPath -> Maybe PosixPath
    [A] takeExtension :: PosixPath -> Maybe PosixPath
    [A] takeDirectory :: PosixPath -> Maybe PosixPath
    [A] splitRoot :: PosixPath -> Maybe (PosixPath, Maybe PosixPath)
    [A] splitPath_ :: Monad m => PosixPath -> Stream m PosixPath
    [A] splitPath :: Monad m => PosixPath -> Stream m PosixPath
    [A] splitLast :: PosixPath -> (Maybe PosixPath, PosixPath)
    [A] splitFirst :: PosixPath -> (PosixPath, Maybe PosixPath)
    [A] splitFile :: PosixPath -> Maybe (Maybe PosixPath, PosixPath)
    [A] splitExtension :: PosixPath -> Maybe (PosixPath, PosixPath)
    [A] showArray :: PosixPath -> [Char]
    [A] separator :: Word8
    [A] replaceExtension :: PosixPath -> PosixPath -> PosixPath
    [A] readArray :: [Char] -> PosixPath
    [A] pathE :: String -> Q Exp
    [A] path :: QuasiQuoter
    [A] normalize :: EqCfg -> PosixPath -> PosixPath
    [A] joinStr :: PosixPath -> [Char] -> PosixPath
    [A] joinDir :: PosixPath -> PosixPath -> PosixPath
    [A] joinCStr' :: PosixPath -> CString -> IO PosixPath
    [A] joinCStr :: PosixPath -> CString -> IO PosixPath
    [A] join :: PosixPath -> PosixPath -> PosixPath
    [A] isValidPath :: Array Word8 -> Bool
    [A] isUnrooted :: PosixPath -> Bool
    [A] isSeparator :: Word8 -> Bool
    [A] isRooted :: PosixPath -> Bool
    [A] ignoreTrailingSeparators :: Bool -> EqCfg -> EqCfg
    [A] ignoreCase :: Bool -> EqCfg -> EqCfg
    [A] hasTrailingSeparator :: PosixPath -> Bool
    [A] fromString_ :: [Char] -> PosixPath
    [A] fromString :: MonadThrow m => [Char] -> m PosixPath
    [A] fromPath :: (IsPath a b, MonadThrow m) => a -> m b
    [A] fromChars :: MonadThrow m => Stream Identity Char -> m PosixPath
    [A] fromArray :: MonadThrow m => Array Word8 -> m PosixPath
    [A] extSeparator :: Word8
    [A] eqPathBytes :: PosixPath -> PosixPath -> Bool
    [A] eqPath :: (EqCfg -> EqCfg) -> PosixPath -> PosixPath -> Bool
    [A] encodeString :: [Char] -> Array Word8
    [A] dropTrailingSeparators :: PosixPath -> PosixPath
    [A] dropExtension :: PosixPath -> PosixPath
    [A] charToWord :: Char -> Word8
    [A] asCString :: PosixPath -> (CString -> IO a) -> IO a
    [A] allowRelativeEquality :: Bool -> EqCfg -> EqCfg
    [A] addTrailingSeparator :: PosixPath -> PosixPath
    [A] addExtension :: PosixPath -> PosixPath -> PosixPath
    [A] adapt :: (MonadThrow m, IsPath PosixPath a, IsPath PosixPath b) => a -> m b
[A] Streamly.Internal.FileSystem.Posix.ReadDir
    [A] DirStream
        [A] DirStream :: Ptr CDir -> DirStream
    [A] reader :: (MonadIO m, MonadCatch m) => Unfold m Path Path
    [A] readScanWith_ :: Scanl m (Path, CString) a -> (ReadOptions -> ReadOptions) -> Path -> Stream m a
    [A] readScanWith :: Scanl m (Path, CString, Ptr CDirent) a -> (ReadOptions -> ReadOptions) -> Path -> Stream m a
    [A] readPlusScanWith :: Scanl m (Path, CString, Ptr CStat) a -> (ReadOptions -> ReadOptions) -> Path -> Stream m a
    [A] readEitherChunks :: MonadIO m => (ReadOptions -> ReadOptions) -> [PosixPath] -> Stream m (Either [PosixPath] [PosixPath])
    [A] readEitherByteChunksAt :: MonadIO m => (ReadOptions -> ReadOptions) -> (PosixPath, [PosixPath]) -> Stream m (Either (PosixPath, [PosixPath]) (Array Word8))
    [A] readEitherByteChunks :: MonadIO m => (ReadOptions -> ReadOptions) -> [PosixPath] -> Stream m (Either [PosixPath] (Array Word8))
    [A] readDirStreamEither :: (ReadOptions -> ReadOptions) -> (PosixPath, DirStream) -> IO (Maybe (Either PosixPath PosixPath))
    [A] openDirStreamCString :: CString -> IO DirStream
    [A] openDirStream :: PosixPath -> IO DirStream
    [A] eitherReader :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
    [A] closeDirStream :: DirStream -> IO ()
[A] Streamly.Internal.FileSystem.Posix.File
    [A] ()
    [A] OpenFlags
        [A] OpenFlags :: CInt -> OpenFlags
    [A] withFile :: PosixPath -> IOMode -> (Handle -> IO r) -> IO r
    [A] withBinaryFile :: PosixPath -> IOMode -> (Handle -> IO r) -> IO r
    [A] setUx :: FileMode -> FileMode
    [A] setUw :: FileMode -> FileMode
    [A] setUr :: FileMode -> FileMode
    [A] setTrunc :: Bool -> OpenFlags -> OpenFlags
    [A] setSync :: Bool -> OpenFlags -> OpenFlags
    [A] setSuid :: FileMode -> FileMode
    [A] setSticky :: FileMode -> FileMode
    [A] setSgid :: FileMode -> FileMode
    [A] setOx :: FileMode -> FileMode
    [A] setOw :: FileMode -> FileMode
    [A] setOr :: FileMode -> FileMode
    [A] setNonBlock :: Bool -> OpenFlags -> OpenFlags
    [A] setNoFollow :: Bool -> OpenFlags -> OpenFlags
    [A] setNoCtty :: Bool -> OpenFlags -> OpenFlags
    [A] setGx :: FileMode -> FileMode
    [A] setGw :: FileMode -> FileMode
    [A] setGr :: FileMode -> FileMode
    [A] setExcl :: Bool -> OpenFlags -> OpenFlags
    [A] setDirectory :: Bool -> OpenFlags -> OpenFlags
    [A] setCloExec :: Bool -> OpenFlags -> OpenFlags
    [A] setAppend :: Bool -> OpenFlags -> OpenFlags
    [A] openFile :: PosixPath -> IOMode -> IO Handle
    [A] openBinaryFile :: PosixPath -> IOMode -> IO Handle
    [A] openAt :: Maybe Fd -> PosixPath -> OpenFlags -> Maybe FileMode -> IO Fd
    [A] defaultOpenFlags :: OpenFlags
    [A] defaultCreateMode :: FileMode
    [A] clrUx :: FileMode -> FileMode
    [A] clrUw :: FileMode -> FileMode
    [A] clrUr :: FileMode -> FileMode
    [A] clrSuid :: FileMode -> FileMode
    [A] clrSticky :: FileMode -> FileMode
    [A] clrSgid :: FileMode -> FileMode
    [A] clrOx :: FileMode -> FileMode
    [A] clrOw :: FileMode -> FileMode
    [A] clrOr :: FileMode -> FileMode
    [A] clrGx :: FileMode -> FileMode
    [A] clrGw :: FileMode -> FileMode
    [A] clrGr :: FileMode -> FileMode
    [A] close :: Fd -> IO ()
[A] Streamly.Internal.FileSystem.Posix.Errno
    [A] throwErrnoPathIfRetry :: (a -> Bool) -> String -> PosixPath -> IO a -> IO a
    [A] throwErrnoPathIfNullRetry :: String -> PosixPath -> IO (Ptr a) -> IO (Ptr a)
    [A] throwErrnoPathIfMinus1Retry :: (Eq a, Num a) => String -> PosixPath -> IO a -> IO a
    [A] throwErrnoPath :: String -> PosixPath -> IO a
[A] Streamly.Internal.FileSystem.Path.SegNode
[A] Streamly.Internal.FileSystem.Path.Seg
[A] Streamly.Internal.FileSystem.Path.Node
[C] Streamly.Internal.FileSystem.Path
    [C] IsPath
        [O] class IsPath a
        [N] class IsPath a b
    [R] Rel
    [R] File
    [A] EqCfg
    [R] Dir
    [R] Abs
    [R] Streamly.Internal.FileSystem.Path.IsPath
    [R] GHC.Show.Show
    [R] GHC.Exception.Type.Exception
    [R] GHC.Classes.Eq
    [R] Path
    [A] type Path = PosixPath
    [A] type OsWord = Word8
    [A] type OsCString = CString
    [A] wordToChar :: OsWord -> Char
    [A] validatePath :: MonadThrow m => Array OsWord -> m ()
    [A] unsafeJoinPaths :: [Path] -> Path
    [A] unsafeJoin :: Path -> Path -> Path
    [A] unsafeFromString :: [Char] -> Path
    [A] unsafeFromPath :: IsPath a b => a -> b
    [A] unsafeFromArray :: Array OsWord -> Path
    [A] toString_ :: Path -> [Char]
    [C] toPath
        [O] toPath :: IsPath a => a -> Path
        [N] toPath :: IsPath a b => b -> a
    [R] toChunk :: Path -> Array Word8
    [A] toChars_ :: Monad m => Path -> Stream m Char
    [A] toArray :: Path -> Array OsWord
    [A] takeFileName :: Path -> Maybe Path
    [A] takeFileBase :: Path -> Maybe Path
    [A] takeExtension :: Path -> Maybe Path
    [A] takeDirectory :: Path -> Maybe Path
    [A] splitRoot :: Path -> Maybe (Path, Maybe Path)
    [A] splitPath_ :: Monad m => Path -> Stream m Path
    [A] splitPath :: Monad m => Path -> Stream m Path
    [A] splitLast :: Path -> (Maybe Path, Path)
    [A] splitFirst :: Path -> (Path, Maybe Path)
    [A] splitFile :: Path -> Maybe (Maybe Path, Path)
    [A] splitExtension :: Path -> Maybe (Path, Path)
    [A] showArray :: Path -> [Char]
    [A] separator :: OsWord
    [A] replaceExtension :: Path -> Path -> Path
    [R] relfile :: QuasiQuoter
    [R] reldir :: QuasiQuoter
    [R] rel :: QuasiQuoter
    [A] readArray :: [Char] -> Path
    [R] primarySeparator :: Char
    [A] pathE :: String -> Q Exp
    [A] normalize :: EqCfg -> Path -> Path
    [R] mkRelFile :: String -> Q Exp
    [R] mkRelDir :: String -> Q Exp
    [R] mkRel :: String -> Q Exp
    [R] mkPath :: String -> Q Exp
    [R] mkFile :: String -> Q Exp
    [R] mkDir :: String -> Q Exp
    [R] mkAbsFile :: String -> Q Exp
    [R] mkAbsDir :: String -> Q Exp
    [R] mkAbs :: String -> Q Exp
    [A] joinStr :: Path -> [Char] -> Path
    [A] joinDir :: Path -> Path -> Path
    [A] joinCStr' :: Path -> CString -> IO Path
    [A] joinCStr :: Path -> CString -> IO Path
    [A] join :: Path -> Path -> Path
    [A] isValidPath :: Array OsWord -> Bool
    [A] isUnrooted :: Path -> Bool
    [C] isSeparator
        [O] isSeparator :: Char -> Bool
        [N] isSeparator :: OsWord -> Bool
    [A] isRooted :: Path -> Bool
    [A] ignoreTrailingSeparators :: Bool -> EqCfg -> EqCfg
    [A] ignoreCase :: Bool -> EqCfg -> EqCfg
    [A] hasTrailingSeparator :: Path -> Bool
    [A] fromString_ :: [Char] -> Path
    [R] fromPathUnsafe :: IsPath a => Path -> a
    [C] fromPath
        [O] fromPath :: (IsPath a, MonadThrow m) => Path -> m a
        [N] fromPath :: (IsPath a b, MonadThrow m) => a -> m b
    [R] fromChunkUnsafe :: Array Word8 -> Path
    [R] fromChunk :: MonadThrow m => Array Word8 -> m Path
    [A] fromArray :: MonadThrow m => Array OsWord -> m Path
    [R] file :: QuasiQuoter
    [R] extendPath :: Path -> Path -> Path
    [R] extendDir :: (IsPath (a (Dir Path)), IsPath b, IsPath (a b)) => a (Dir Path) -> Rel b -> a b
    [A] extSeparator :: OsWord
    [A] eqPathBytes :: Path -> Path -> Bool
    [A] eqPath :: (EqCfg -> EqCfg) -> Path -> Path -> Bool
    [A] encodeString :: [Char] -> Array OsWord
    [A] dropTrailingSeparators :: Path -> Path
    [A] dropExtension :: Path -> Path
    [R] dir :: QuasiQuoter
    [A] charToWord :: Char -> OsWord
    [A] asOsCString :: Path -> (OsCString -> IO a) -> IO a
    [A] allowRelativeEquality :: Bool -> EqCfg -> EqCfg
    [A] addTrailingSeparator :: Path -> Path
    [A] addExtension :: Path -> Path -> Path
    [R] adaptPath :: (MonadThrow m, IsPath a, IsPath b) => a -> m b
    [A] adapt :: (MonadThrow m, IsPath Path a, IsPath Path b) => a -> m b
    [R] absfile :: QuasiQuoter
    [R] absdir :: QuasiQuoter
    [R] abs :: QuasiQuoter
[C] Streamly.Internal.FileSystem.Handle
    [C] writeChunks
        [O] writeChunks :: MonadIO m => Handle -> Fold m (Array a) ()
        [N] writeChunks :: forall m (a :: Type). MonadIO m => Handle -> Fold m (Array a) ()
    [C] putChunks
        [O] putChunks :: MonadIO m => Handle -> Stream m (Array a) -> m ()
        [N] putChunks :: forall m (a :: Type). MonadIO m => Handle -> Stream m (Array a) -> m ()
    [C] putChunk
        [O] putChunk :: MonadIO m => Handle -> Array a -> m ()
        [N] putChunk :: forall m (a :: Type). MonadIO m => Handle -> Array a -> m ()
    [C] chunkWriter
        [O] chunkWriter :: MonadIO m => Refold m Handle (Array a) ()
        [N] chunkWriter :: forall m (a :: Type). MonadIO m => Refold m Handle (Array a) ()
[A] Streamly.Internal.FileSystem.FileIO
    [A] writeWith :: (MonadIO m, MonadCatch m) => Int -> Path -> Fold m Word8 ()
    [A] writeChunks :: (MonadIO m, MonadCatch m) => Path -> Fold m (Array a) ()
    [A] writeAppendWith :: (MonadIO m, MonadCatch m) => Int -> Path -> Stream m Word8 -> m ()
    [A] writeAppendChunks :: (MonadIO m, MonadCatch m) => Path -> Stream m (Array a) -> m ()
    [A] writeAppendArray :: Path -> Array a -> IO ()
    [A] writeAppend :: (MonadIO m, MonadCatch m) => Path -> Stream m Word8 -> m ()
    [A] write :: (MonadIO m, MonadCatch m) => Path -> Fold m Word8 ()
    [A] withFile :: (MonadIO m, MonadCatch m) => Path -> IOMode -> (Handle -> Stream m a) -> Stream m a
    [A] readerWith :: (MonadIO m, MonadCatch m) => Unfold m (Int, Path) Word8
    [A] reader :: (MonadIO m, MonadCatch m) => Unfold m Path Word8
    [A] readChunksWith :: (MonadIO m, MonadCatch m) => Int -> Path -> Stream m (Array Word8)
    [A] readChunks :: (MonadIO m, MonadCatch m) => Path -> Stream m (Array Word8)
    [A] read :: (MonadIO m, MonadCatch m) => Path -> Stream m Word8
    [A] putChunk :: Path -> Array a -> IO ()
    [A] fromChunks :: (MonadIO m, MonadCatch m) => Path -> Stream m (Array a) -> m ()
    [A] fromBytesWith :: (MonadIO m, MonadCatch m) => Int -> Path -> Stream m Word8 -> m ()
    [A] fromBytes :: (MonadIO m, MonadCatch m) => Path -> Stream m Word8 -> m ()
    [A] chunkReaderWith :: (MonadIO m, MonadCatch m) => Unfold m (Int, Path) (Array Word8)
    [A] chunkReaderFromToWith :: (MonadIO m, MonadCatch m) => Unfold m (Int, Int, Int, Path) (Array Word8)
    [A] chunkReader :: (MonadIO m, MonadCatch m) => Unfold m Path (Array Word8)
[A] Streamly.Internal.FileSystem.File.Common
    [A] withFile :: Bool -> (Path -> IOMode -> IO Handle) -> Path -> IOMode -> (Handle -> IO r) -> IO r
    [A] openFile :: Bool -> (Path -> IOMode -> IO Handle) -> Path -> IOMode -> IO Handle
[D] Streamly.Internal.FileSystem.File
    [C] writeChunks
        [O] writeChunks :: (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
        [N] writeChunks :: forall m (a :: Type). (MonadIO m, MonadCatch m) => FilePath -> Fold m (Array a) ()
    [C] writeAppendChunks
        [O] writeAppendChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m ()
        [N] writeAppendChunks :: forall m (a :: Type). (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m ()
    [C] writeAppendArray
        [O] writeAppendArray :: FilePath -> Array a -> IO ()
        [N] writeAppendArray :: forall (a :: Type). FilePath -> Array a -> IO ()
    [C] putChunk
        [O] putChunk :: FilePath -> Array a -> IO ()
        [N] putChunk :: forall (a :: Type). FilePath -> Array a -> IO ()
    [C] fromChunks
        [O] fromChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m ()
        [N] fromChunks :: forall m (a :: Type). (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m ()
[A] Streamly.Internal.FileSystem.DirIO
    [A] ReadOptions
        [A] [_ignoreENOENT] :: ReadOptions -> Bool
        [A] [_ignoreELOOP] :: ReadOptions -> Bool
        [A] [_ignoreEACCESS] :: ReadOptions -> Bool
        [A] [_followSymlinks] :: ReadOptions -> Bool
        [A] ReadOptions :: Bool -> Bool -> Bool -> Bool -> ReadOptions
    [A] reader :: (MonadIO m, MonadCatch m) => Unfold m Path Path
    [A] readFiles :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Path -> Stream m Path
    [A] readEitherPaths :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Path -> Stream m (Either Path Path)
    [A] readEitherChunks :: MonadIO m => (ReadOptions -> ReadOptions) -> [PosixPath] -> Stream m (Either [PosixPath] [PosixPath])
    [A] readEither :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Path -> Stream m (Either Path Path)
    [A] readDirs :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Path -> Stream m Path
    [A] read :: (MonadIO m, MonadCatch m) => Path -> Stream m Path
    [A] ignoreSymlinkLoops :: Bool -> ReadOptions -> ReadOptions
    [A] ignoreMissing :: Bool -> ReadOptions -> ReadOptions
    [A] ignoreInaccessible :: Bool -> ReadOptions -> ReadOptions
    [A] followSymlinks :: Bool -> ReadOptions -> ReadOptions
    [A] fileReader :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Unfold m Path Path
    [A] eitherReaderPaths :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
    [A] eitherReader :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Unfold m Path (Either Path Path)
    [A] dirReader :: (MonadIO m, MonadCatch m) => (ReadOptions -> ReadOptions) -> Unfold m Path Path
    [A] defaultReadOptions :: ReadOptions
[D] Streamly.Internal.FileSystem.Dir
[C] Streamly.Internal.Data.Unfold
    [A] zipRepeat :: Functor m => Unfold m a b -> Unfold m (c, a) (c, b)
    [A] zipArrowWithM :: Monad m => (b -> c -> m d) -> Unfold m a1 b -> Unfold m a2 c -> Unfold m (a1, a2) d
    [A] zipArrowWith :: Monad m => (b -> c -> d) -> Unfold m a1 b -> Unfold m a2 c -> Unfold m (a1, a2) d
    [A] unfoldEachInterleave :: Monad m => Unfold m a b -> Unfold m c a -> Unfold m c b
    [A] unfoldEach :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
    [A] supply :: a -> Unfold m a b -> Unfold m () b
    [A] scanlMany :: Monad m => Scanl m b c -> Unfold m a b -> Unfold m a c
    [A] scanl :: Monad m => Scanl m b c -> Unfold m a b -> Unfold m a c
    [D] scanMany :: Monad m => Fold m b c -> Unfold m a b -> Unfold m a c
    [D] scan :: Monad m => Fold m b c -> Unfold m a b -> Unfold m a c
    [A] repeat :: Applicative m => Unfold m a a
    [D] mapM2 :: Monad m => (a -> b -> m c) -> Unfold m a b -> Unfold m a c
    [D] map2 :: Functor m => (a -> b -> c) -> Unfold m a b -> Unfold m a c
    [D] manyInterleave :: Monad m => Unfold m a b -> Unfold m c a -> Unfold m c b
    [D] many2 :: Monad m => Unfold m (a, b) c -> Unfold m a b -> Unfold m a c
    [D] many :: Monad m => Unfold m b c -> Unfold m a b -> Unfold m a c
    [R] joinInnerGeneric :: Monad m => (b -> c -> Bool) -> Unfold m a b -> Unfold m a c -> Unfold m a (b, c)
    [A] interleave :: Monad m => Unfold m a c -> Unfold m b c -> Unfold m (a, b) c
    [A] innerJoin :: Monad m => (b -> c -> Bool) -> Unfold m a b -> Unfold m a c -> Unfold m a (b, c)
    [A] fromTuple :: Applicative m => Unfold m (a, a) a
    [A] fairCrossWithM :: Monad m => (b -> c -> m d) -> Unfold m a b -> Unfold m a c -> Unfold m a d
    [A] fairCrossWith :: Monad m => (b -> c -> d) -> Unfold m a b -> Unfold m a c -> Unfold m a d
    [A] fairCross :: Monad m => Unfold m a b -> Unfold m a c -> Unfold m a (b, c)
    [A] carry :: Functor m => Unfold m a b -> Unfold m a (a, b)
    [D] both :: a -> Unfold m a b -> Unfold m Void b
[C] Streamly.Internal.Data.StreamK
    [R] CrossStreamK
    [A] Nested
        [A] [unNested] :: Nested m a -> StreamK m a
        [A] Nested :: StreamK m a -> Nested m a
    [A] FairNested
        [A] [unFairNested] :: FairNested m a -> StreamK m a
        [A] FairNested :: StreamK m a -> FairNested m a
    [A] toParserK :: Monad m => Parser a m b -> ParserK a m b
    [A] tailNonEmpty :: StreamK m a -> StreamK m a
    [A] sortOn :: (Monad m, Ord b) => (a -> b) -> StreamK m a -> StreamK m a
    [A] parsePos :: Monad m => ParserK a m b -> StreamK m a -> m (Either ParseErrorPos b)
    [C] parseDBreak
        [O] parseDBreak :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseError b, StreamK m a)
        [N] parseDBreak :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseErrorPos b, StreamK m a)
    [C] parseD
        [O] parseD :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseError b)
        [N] parseD :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseErrorPos b)
    [D] parseChunksGeneric :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [D] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [A] parseBreakPos :: forall m a b. Monad m => ParserK a m b -> StreamK m a -> m (Either ParseErrorPos b, StreamK m a)
    [D] parseBreakChunksGeneric :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [D] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] morphInner :: (Monad m, Monad n) => (forall x. m x -> n x) -> StreamK m a -> StreamK n a
    [D] mkCross :: StreamK m a -> Nested m a
    [A] mapMAccum :: (s -> a -> m (s, b)) -> m s -> StreamK m a -> StreamK m b
    [A] localReaderT :: (r -> r) -> StreamK (ReaderT r m) a -> StreamK (ReaderT r m) a
    [A] interleaveSepBy :: StreamK m a -> StreamK m a -> StreamK m a
    [D] interleaveMin :: StreamK m a -> StreamK m a -> StreamK m a
    [D] interleaveFst :: StreamK m a -> StreamK m a -> StreamK m a
    [A] interleaveEndBy' :: StreamK m a -> StreamK m a -> StreamK m a
    [A] initNonEmpty :: Stream m a -> Stream m a
    [D] hoist :: (Monad m, Monad n) => (forall x. m x -> n x) -> StreamK m a -> StreamK n a
    [A] headNonEmpty :: Monad m => StreamK m a -> m a
    [A] fairConcatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] fairConcatForM :: Monad m => StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] fairConcatFor :: StreamK m a -> (a -> StreamK m b) -> StreamK m b
    [A] concatMapMAccum :: (StreamK m b -> StreamK m b -> StreamK m b) -> (s -> a -> m (s, StreamK m b)) -> m s -> StreamK m a -> StreamK m b
    [A] concatForWithM :: Monad m => (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] concatForWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m a -> (a -> StreamK m b) -> StreamK m b
    [A] concatForM :: Monad m => StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] concatFor :: StreamK m a -> (a -> StreamK m b) -> StreamK m b
    [D] bindWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m a -> (a -> StreamK m b) -> StreamK m b
    [A] bfsConcatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b
    [A] bfsConcatForM :: Monad m => StreamK m a -> (a -> m (StreamK m b)) -> StreamK m b
    [A] bfsConcatFor :: StreamK m a -> (a -> StreamK m b) -> StreamK m b
[C] Streamly.Internal.Data.Stream
    [A] FairUnfoldState
        [A] FairUnfoldNext :: o -> ([i] -> [i]) -> [i] -> FairUnfoldState o i
        [A] FairUnfoldInit :: o -> ([i] -> [i]) -> FairUnfoldState o i
        [A] FairUnfoldDrain :: ([i] -> [i]) -> [i] -> FairUnfoldState o i
    [R] CrossStream
    [A] Nested
        [A] [unNested] :: Nested m a -> Stream m a
        [A] Nested :: Stream m a -> Nested m a
    [A] withReaderT :: Monad m => (r2 -> r1) -> Stream (ReaderT r1 m) a -> Stream (ReaderT r2 m) a
    [A] withAcquireIO' :: AcquireIO -> (AcquireIO -> Stream m a) -> Stream m a
    [A] withAcquireIO :: (MonadIO m, MonadCatch m) => (AcquireIO -> Stream m a) -> Stream m a
    [C] usingStateT
        [O] usingStateT :: Monad m => m s -> (Stream (StateT s m) a -> Stream (StateT s m) a) -> Stream m a -> Stream m a
        [N] usingStateT :: Monad m => m s -> (Stream (StateT s m) a -> Stream (StateT s m) b) -> Stream m a -> Stream m b
    [R] unionWithStreamGenericBy :: MonadIO m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [R] unionWithStreamAscBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] unionBy :: MonadIO m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [A] unfoldSched :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [D] unfoldRoundRobin :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [D] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [D] unfoldIterateDfs :: Monad m => Unfold m a a -> Stream m a -> Stream m a
    [D] unfoldIterateBfsRev :: Monad m => Unfold m a a -> Stream m a -> Stream m a
    [D] unfoldIterateBfs :: Monad m => Unfold m a a -> Stream m a -> Stream m a
    [A] unfoldIterate :: Monad m => Unfold m a a -> Stream m a -> Stream m a
    [D] unfoldInterleave :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] unfoldEachSepBySeq :: Monad m => b -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEachSepByM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEachSepBy :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEachFoldBy :: Fold m b c -> Unfold m a b -> Stream m a -> Stream m c
    [A] unfoldEachEndBySeq :: Monad m => b -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEachEndByM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEachEndBy :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c
    [A] unfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] unfoldCross :: Monad m => Unfold m (a, b) c -> Stream m a -> Stream m b -> Stream m c
    [C] unCross
        [O] unCross :: CrossStream m a -> Stream m a
        [N] unCross :: Nested m a -> Stream m a
    [R] transform :: Monad m => Pipe m a b -> Stream m a -> Stream m b
    [A] takeEndBy_ :: Monad m => (a -> Bool) -> Stream m a -> Stream m a
    [A] takeEndBySeq_ :: forall m a. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Stream m a -> Stream m a
    [A] takeEndBySeq :: forall m a. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Stream m a -> Stream m a
    [A] tailNonEmpty :: Monad m => Stream m a -> Stream m a
    [D] strideFromThen :: Monad m => Int -> Int -> Stream m a -> Stream m a
    [A] splitSepBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
    [A] splitSepBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [A] splitSepBySeqOneOf :: [Array a] -> Fold m a b -> Stream m a -> Stream m b
    [R] splitOnSuffixSeqAny :: [Array a] -> Fold m a b -> Stream m a -> Stream m b
    [C] splitOnSuffixSeq
        [O] splitOnSuffixSeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) => Bool -> Array a -> Fold m a b -> Stream m a -> Stream m b
        [N] splitOnSuffixSeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Bool -> Array a -> Fold m a b -> Stream m a -> Stream m b
    [D] splitOnSeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [R] splitOnPrefix :: (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
    [R] splitOnAny :: [Array a] -> Fold m a b -> Stream m a -> Stream m b
    [D] splitOn :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
    [A] splitEndBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [A] splitEndBySeqOneOf :: [Array a] -> Fold m a b -> Stream m a -> Stream m b
    [A] splitEndBySeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b
    [A] splitBeginBy_ :: (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b
    [A] splitAt :: String -> Int -> [a] -> ([a], [a])
    [A] sortedUnionBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] sortedIntersectBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] sortedDeleteFirstsBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [R] slicesBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
    [A] schedMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
    [A] schedMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
    [A] schedForM :: Monad m => Stream m a -> (a -> m (Stream m b)) -> Stream m b
    [A] schedFor :: Monad m => Stream m a -> (a -> Stream m b) -> Stream m b
    [A] scanr :: Monad m => Scanr m a b -> Stream m a -> Stream m b
    [A] scanlMany :: Monad m => Scanl m a b -> Stream m a -> Stream m b
    [A] scanlBy :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b
    [C] scanl
        [O] scanl :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b
        [N] scanl :: Monad m => Scanl m a b -> Stream m a -> Stream m b
    [D] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b
    [D] scanMany :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [D] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] sampleFromThen :: Monad m => Int -> Int -> Stream m a -> Stream m a
    [D] reduceIterateBfs :: Monad m => (a -> a -> m a) -> Stream m a -> m (Maybe a)
    [A] postscanlMaybe :: Monad m => Scanl m a (Maybe b) -> Stream m a -> Stream m b
    [A] postscanlBy :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
    [C] postscanl
        [O] postscanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a
        [N] postscanl :: Monad m => Scanl m a b -> Stream m a -> Stream m b
    [D] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b
    [A] pipe :: Monad m => Pipe m a b -> Stream m a -> Stream m b
    [A] parsePos :: Monad m => Parser a m b -> Stream m a -> m (Either ParseErrorPos b)
    [A] parseManyPos :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseErrorPos b)
    [D] parseManyD :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b)
    [A] parseIteratePos :: Monad m => (b -> Parser a m b) -> b -> Stream m a -> Stream m (Either ParseErrorPos b)
    [D] parseIterateD :: Monad m => (b -> Parser a m b) -> b -> Stream m a -> Stream m (Either ParseError b)
    [D] parseD :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b)
    [A] parseBreakPos :: Monad m => Parser a m b -> Stream m a -> m (Either ParseErrorPos b, Stream m a)
    [D] parseBreakD :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a)
    [A] outerSortedJoin :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b)
    [A] outerOrdJoin :: (Ord k, MonadIO m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, Maybe a, Maybe b)
    [A] outerJoin :: MonadIO m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b)
    [A] ordNub :: (Monad m, Ord a) => Stream m a -> Stream m a
    [R] nub :: (Monad m, Ord a) => Stream m a -> Stream m a
    [D] mkCross :: Stream m a -> Nested m a
    [A] loopBy :: Monad m => Unfold m x b -> x -> Stream m a -> Stream m (a, b)
    [A] loop :: Monad m => Stream m b -> Stream m a -> Stream m (a, b)
    [A] localReaderT :: Monad m => (r -> r) -> Stream (ReaderT r m) a -> Stream (ReaderT r m) a
    [A] leftSortedJoin :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, Maybe b)
    [A] leftOrdJoin :: (Ord k, Monad m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, Maybe b)
    [A] leftJoin :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, Maybe b)
    [R] joinOuterGeneric :: MonadIO m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b)
    [R] joinOuterAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b)
    [R] joinOuter :: (Ord k, MonadIO m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, Maybe a, Maybe b)
    [R] joinLeftGeneric :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, Maybe b)
    [R] joinLeftAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, Maybe b)
    [R] joinLeft :: (Ord k, Monad m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, Maybe b)
    [R] joinInnerGeneric :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, b)
    [R] joinInnerAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, b)
    [R] joinInner :: (Monad m, Ord k) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, b)
    [C] isInfixOf
        [O] isInfixOf :: (MonadIO m, Eq a, Enum a, Storable a, Unbox a) => Stream m a -> Stream m a -> m Bool
        [N] isInfixOf :: (MonadIO m, Eq a, Enum a, Unbox a) => Stream m a -> Stream m a -> m Bool
    [R] intersperseMWith :: Int -> m a -> Stream m a -> Stream m a
    [D] intersperseMSuffix_ :: Monad m => m b -> Stream m a -> Stream m a
    [D] intersperseMSuffixWith :: forall m a. Monad m => Int -> m a -> Stream m a -> Stream m a
    [D] intersperseMSuffix :: forall m a. Monad m => m a -> Stream m a -> Stream m a
    [D] intersperseMPrefix_ :: Monad m => m b -> Stream m a -> Stream m a
    [A] intersperseEveryM :: Int -> m a -> Stream m a -> Stream m a
    [A] intersperseEndByM_ :: Monad m => m b -> Stream m a -> Stream m a
    [A] intersperseEndByM :: forall m a. Monad m => m a -> Stream m a -> Stream m a
    [A] intersperseEndByEveryM :: forall m a. Monad m => Int -> m a -> Stream m a -> Stream m a
    [A] intersperseBeginByM_ :: Monad m => m b -> Stream m a -> Stream m a
    [R] intersectBySorted :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] intersectBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [D] interposeSuffixM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c
    [D] interposeSuffix :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c
    [D] interposeM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c
    [D] interpose :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c
    [A] interleaveSepBy' :: Monad m => Stream m a -> Stream m a -> Stream m a
    [A] interleaveSepBy :: Monad m => Stream m a -> Stream m a -> Stream m a
    [D] interleaveMin :: Monad m => Stream m a -> Stream m a -> Stream m a
    [D] interleaveFstSuffix :: Monad m => Stream m a -> Stream m a -> Stream m a
    [D] interleaveFst :: Monad m => Stream m a -> Stream m a -> Stream m a
    [A] interleaveEndBy' :: Monad m => Stream m a -> Stream m a -> Stream m a
    [A] interleaveEndBy :: Monad m => Stream m a -> Stream m a -> Stream m a
    [A] interleaveBeginBy :: Stream m a -> Stream m a -> Stream m a
    [D] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
    [A] intercalateSepBy :: Monad m => Unfold m b c -> Stream m b -> Unfold m a c -> Stream m a -> Stream m c
    [A] intercalateEndBy :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c
    [D] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c
    [A] innerSortedJoin :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, b)
    [A] innerOrdJoin :: (Monad m, Ord k) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, b)
    [A] innerJoin :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, b)
    [A] initNonEmpty :: Monad m => Stream m a -> Stream m a
    [A] init :: Monad m => Stream m a -> m (Maybe (Stream m a))
    [D] indexOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
    [A] indexEndBy_ :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
    [A] indexEndBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int)
    [D] gintercalateSuffix :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c
    [D] gintercalate :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c
    [A] fromW16CString# :: Monad m => Addr# -> Stream m Word16
    [A] fromCString# :: Monad m => Addr# -> Stream m Word8
    [D] fromByteStr# :: Monad m => Addr# -> Stream m Word8
    [A] foldManySepBy :: Fold m a b -> Fold m a b -> Stream m a -> Stream m b
    [R] foldIterateBfs :: Fold m a (Either a a) -> Stream m a -> m (Maybe a)
    [A] finallyIO'' :: (MonadIO m, MonadCatch m) => AcquireIO -> IO b -> Stream m a -> Stream m a
    [A] finallyIO' :: MonadIO m => AcquireIO -> IO b -> Stream m a -> Stream m a
    [R] filterInStreamGenericBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [R] filterInStreamAscBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] fairUnfoldSched :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] fairUnfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] fairSchedMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
    [A] fairSchedMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
    [A] fairSchedForM :: Monad m => Stream m a -> (a -> m (Stream m b)) -> Stream m b
    [A] fairSchedFor :: Monad m => Stream m a -> (a -> Stream m b) -> Stream m b
    [A] fairCrossWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c
    [A] fairCrossWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c
    [A] fairCross :: Monad m => Stream m a -> Stream m b -> Stream m (a, b)
    [A] fairConcatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b
    [A] fairConcatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b
    [A] fairConcatForM :: Monad m => Stream m a -> (a -> m (Stream m b)) -> Stream m b
    [A] fairConcatFor :: Monad m => Stream m a -> (a -> Stream m b) -> Stream m b
    [R] deleteInStreamGenericBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [R] deleteInStreamAscBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a
    [A] deleteFirstsBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a
    [D] concatIterateDfs :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
    [D] concatIterateBfsRev :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
    [D] concatIterateBfs :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
    [A] concatIterate :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
    [A] concatForM :: Monad m => Stream m a -> (a -> m (Stream m b)) -> Stream m b
    [A] concatFor :: Monad m => Stream m a -> (a -> Stream m b) -> Stream m b
    [A] bracketIO'' :: (MonadIO m, MonadCatch m) => AcquireIO -> IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
    [A] bracketIO' :: MonadIO m => AcquireIO -> IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a
    [A] bfsUnfoldIterate :: Monad m => Unfold m a a -> Stream m a -> Stream m a
    [A] bfsUnfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] bfsReduceIterate :: Monad m => (a -> a -> m a) -> Stream m a -> m (Maybe a)
    [A] bfsFoldIterate :: Fold m a (Either a a) -> Stream m a -> m (Maybe a)
    [A] bfsConcatIterate :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
    [A] altBfsUnfoldIterate :: Monad m => Unfold m a a -> Stream m a -> Stream m a
    [A] altBfsUnfoldEach :: Monad m => Unfold m a b -> Stream m a -> Stream m b
    [A] altBfsConcatIterate :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a
[A] Streamly.Internal.Data.Scanr
    [A] Scanr
        [A] Scanr :: (s -> a -> m (Step s b)) -> s -> Scanr m a b
    [A] GHC.Base.Functor
        [A] instance GHC.Base.Functor m => GHC.Base.Functor (Streamly.Internal.Data.Scanr.Scanr m a)
    [A] GHC.Base.Applicative
        [A] instance GHC.Base.Monad m => GHC.Base.Applicative (Streamly.Internal.Data.Scanr.Scanr m a)
    [A] Control.Category.Category
        [A] instance GHC.Base.Monad m => Control.Category.Category (Streamly.Internal.Data.Scanr.Scanr m)
    [A] Control.Arrow.Arrow
        [A] instance GHC.Base.Monad m => Control.Arrow.Arrow (Streamly.Internal.Data.Scanr.Scanr m)
    [A] teeWithMay :: Monad m => (Maybe b -> Maybe c -> d) -> Scanr m a b -> Scanr m a c -> Scanr m a d
    [A] teeWith :: Monad m => (b -> c -> d) -> Scanr m a b -> Scanr m a c -> Scanr m a d
    [A] tee :: Monad m => Scanr m a b -> Scanr m a c -> Scanr m a (b, c)
    [A] sum :: (Monad m, Num a) => Scanr m a a
    [A] length :: Monad m => Scanr m a Int
    [A] identity :: Monad m => Scanr m a a
    [A] functionM :: Monad m => (a -> m b) -> Scanr m a b
    [A] function :: Monad m => (a -> b) -> Scanr m a b
    [A] filterM :: Monad m => (a -> m Bool) -> Scanr m a a
    [A] filter :: Monad m => (a -> Bool) -> Scanr m a a
    [A] compose :: Monad m => Scanr m b c -> Scanr m a b -> Scanr m a c
[A] Streamly.Internal.Data.Scanl
    [A] Step
        [A] Partial :: !s -> Step s b
        [A] Done :: !b -> Step s b
    [A] Scanl
        [A] Scanl :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> (s -> m b) -> Scanl m a b
    [A] Incr
        [A] Replace :: !a -> !a -> Incr a
        [A] Insert :: !a -> Incr a
    [A] zipStreamWithM :: (a -> b -> m c) -> Stream m a -> Scanl m c x -> Scanl m b x
    [A] zipStream :: Monad m => Stream m a -> Scanl m (a, b) x -> Scanl m b x
    [A] with :: (Scanl m (s, a) b -> Scanl m a b) -> (((s, a) -> c) -> Scanl m (s, a) b -> Scanl m (s, a) b) -> ((s, a) -> c) -> Scanl m a b -> Scanl m a b
    [A] windowRange :: forall m a. (MonadIO m, Unbox a, Ord a) => Int -> Scanl m a (Maybe (a, a))
    [A] windowMinimum :: (MonadIO m, Unbox a, Ord a) => Int -> Scanl m a (Maybe a)
    [A] windowMaximum :: (MonadIO m, Unbox a, Ord a) => Int -> Scanl m a (Maybe a)
    [A] unzipWithM :: Monad m => (a -> m (b, c)) -> Scanl m b x -> Scanl m c y -> Scanl m a (x, y)
    [A] unzipWith :: Monad m => (a -> (b, c)) -> Scanl m b x -> Scanl m c y -> Scanl m a (x, y)
    [A] unzip :: Monad m => Scanl m a x -> Scanl m b y -> Scanl m (a, b) (x, y)
    [A] uniqBy :: Monad m => (a -> a -> Bool) -> Scanl m a (Maybe a)
    [A] uniq :: (Monad m, Eq a) => Scanl m a (Maybe a)
    [A] unfoldMany :: Monad m => Unfold m a b -> Scanl m b c -> Scanl m a c
    [A] topBy :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Int -> Scanl m a (MutArray a)
    [A] top :: (MonadIO m, Unbox a, Ord a) => Int -> Scanl m a (MutArray a)
    [A] toStreamRev :: (Monad m, Monad n) => Scanl m a (Stream n a)
    [A] toStreamKRev :: Monad m => Scanl m a (StreamK n a)
    [A] toStreamK :: Monad m => Scanl m a (StreamK n a)
    [A] toStream :: (Monad m, Monad n) => Scanl m a (Stream n a)
    [A] toSet :: (Monad m, Ord a) => Scanl m a (Set a)
    [A] toListRev :: Monad m => Scanl m a [a]
    [A] toList :: Monad m => Scanl m a [a]
    [A] toIntSet :: Monad m => Scanl m Int IntSet
    [A] the :: (Monad m, Eq a) => Scanl m a (Maybe a)
    [A] teeWith :: Monad m => (b -> c -> d) -> Scanl m a b -> Scanl m a c -> Scanl m a d
    [A] tee :: Monad m => Scanl m a b -> Scanl m a c -> Scanl m a (b, c)
    [A] takingEndBy_ :: Monad m => (a -> Bool) -> Scanl m a (Maybe a)
    [A] takingEndByM_ :: Monad m => (a -> m Bool) -> Scanl m a (Maybe a)
    [A] takingEndByM :: Monad m => (a -> m Bool) -> Scanl m a (Maybe a)
    [A] takingEndBy :: Monad m => (a -> Bool) -> Scanl m a (Maybe a)
    [A] taking :: Monad m => Int -> Scanl m a (Maybe a)
    [A] takeEndBy_ :: Monad m => (a -> Bool) -> Scanl m a b -> Scanl m a b
    [A] takeEndBy :: Monad m => (a -> Bool) -> Scanl m a b -> Scanl m a b
    [A] take :: Monad m => Int -> Scanl m a b -> Scanl m a b
    [A] sum :: (Monad m, Num a) => Scanl m a a
    [A] sconcat :: (Monad m, Semigroup a) => a -> Scanl m a a
    [A] scanlMany :: Monad m => Scanl m a b -> Scanl m b c -> Scanl m a c
    [A] scanl :: Monad m => Scanl m a b -> Scanl m b c -> Scanl m a c
    [A] sampleFromthen :: Monad m => Int -> Int -> Scanl m a b -> Scanl m a b
    [A] rollingMapM :: Monad m => (Maybe a -> a -> m b) -> Scanl m a b
    [A] rollingMap :: Monad m => (Maybe a -> a -> b) -> Scanl m a b
    [A] rollingHashWithSalt :: (Monad m, Enum a) => Int64 -> Scanl m a Int64
    [A] rollingHashFirstN :: (Monad m, Enum a) => Int -> Scanl m a Int64
    [A] rollingHash :: (Monad m, Enum a) => Scanl m a Int64
    [A] rmapM :: Monad m => (b -> m c) -> Scanl m a b -> Scanl m a c
    [A] repeated :: Scanl m a (Maybe a)
    [A] rangeBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe (a, a))
    [A] range :: (Monad m, Ord a) => Scanl m a (Maybe (a, a))
    [A] prune :: (a -> Bool) -> Scanl m a (Maybe a)
    [A] product :: (Monad m, Num a, Eq a) => Scanl m a a
    [A] postscanlMaybe :: Monad m => Scanl m a (Maybe b) -> Scanl m b c -> Scanl m a c
    [A] postscanl :: Monad m => Scanl m a b -> Scanl m b c -> Scanl m a c
    [A] pipe :: Monad m => Pipe m a b -> Scanl m b c -> Scanl m a c
    [A] partitionByM :: Monad m => (a -> m (Either b c)) -> Scanl m b x -> Scanl m c x -> Scanl m a x
    [A] partitionBy :: Monad m => (a -> Either b c) -> Scanl m b x -> Scanl m c x -> Scanl m a x
    [A] partition :: Monad m => Scanl m b x -> Scanl m c x -> Scanl m (Either b c) x
    [A] nubInt :: Monad m => Scanl m Int (Maybe Int)
    [A] nub :: (Monad m, Ord a) => Scanl m a (Maybe a)
    [A] morphInner :: (forall x. m x -> n x) -> Scanl m a b -> Scanl n a b
    [A] mkScantM :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> Scanl m a b
    [A] mkScant :: Monad m => (s -> a -> Step s b) -> Step s b -> (s -> b) -> Scanl m a b
    [A] mkScanrM :: Monad m => (a -> b -> m b) -> m b -> Scanl m a b
    [A] mkScanr :: Monad m => (a -> b -> b) -> b -> Scanl m a b
    [A] mkScanlM :: Monad m => (b -> a -> m b) -> m b -> Scanl m a b
    [A] mkScanl1M :: Monad m => (a -> a -> m a) -> Scanl m a (Maybe a)
    [A] mkScanl1 :: Monad m => (a -> a -> a) -> Scanl m a (Maybe a)
    [A] mkScanl :: Monad m => (b -> a -> b) -> b -> Scanl m a b
    [A] minimumBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe a)
    [A] minimum :: (Monad m, Ord a) => Scanl m a (Maybe a)
    [A] mean :: (Monad m, Fractional a) => Scanl m a a
    [A] mconcat :: (Monad m, Monoid a) => Scanl m a a
    [A] maximumBy :: Monad m => (a -> a -> Ordering) -> Scanl m a (Maybe a)
    [A] maximum :: (Monad m, Ord a) => Scanl m a (Maybe a)
    [A] mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Scanl m b r -> Scanl m a r
    [A] mapMaybe :: Monad m => (a -> Maybe b) -> Scanl m b r -> Scanl m a r
    [A] mapMStep :: Applicative m => (a -> m b) -> Step s a -> m (Step s b)
    [A] lmapM :: Monad m => (a -> m b) -> Scanl m b r -> Scanl m a r
    [A] lmap :: (a -> b) -> Scanl m b r -> Scanl m a r
    [A] length :: Monad m => Scanl m a Int
    [A] latest :: Monad m => Scanl m a (Maybe a)
    [A] indexingWith :: Monad m => Int -> (Int -> Int) -> Scanl m a (Maybe (Int, a))
    [A] indexingRev :: Monad m => Int -> Scanl m a (Maybe (Int, a))
    [A] indexing :: Monad m => Scanl m a (Maybe (Int, a))
    [A] indexed :: Monad m => Scanl m (Int, a) b -> Scanl m a b
    [A] incrSumInt :: forall m a. (Monad m, Integral a) => Scanl m (Incr a) a
    [A] incrSum :: forall m a. (Monad m, Num a) => Scanl m (Incr a) a
    [A] incrScanWith :: forall m a b. (MonadIO m, Unbox a) => Int -> Scanl m (Incr a, RingArray a) b -> Scanl m a b
    [A] incrScan :: forall m a b. (MonadIO m, Unbox a) => Int -> Scanl m (Incr a) b -> Scanl m a b
    [A] incrRollingMapM :: Monad m => (Maybe a -> a -> m (Maybe b)) -> Scanl m (Incr a) (Maybe b)
    [A] incrRollingMap :: Monad m => (Maybe a -> a -> Maybe b) -> Scanl m (Incr a) (Maybe b)
    [A] incrPowerSumFrac :: (Monad m, Floating a) => a -> Scanl m (Incr a) a
    [A] incrPowerSum :: (Monad m, Num a) => Int -> Scanl m (Incr a) a
    [A] incrMean :: forall m a. (Monad m, Fractional a) => Scanl m (Incr a) a
    [A] incrCount :: (Monad m, Num b) => Scanl m (Incr a) b
    [A] genericLength :: (Monad m, Num b) => Scanl m a b
    [A] generalizeInner :: Monad m => Scanl Identity a b -> Scanl m a b
    [A] functionM :: Monad m => (a -> m (Maybe b)) -> Scanl m a (Maybe b)
    [A] fromRefold :: Refold m c a b -> c -> Scanl m a b
    [A] foldMapM :: (Monad m, Monoid b) => (a -> m b) -> Scanl m a b
    [A] foldMap :: (Monad m, Monoid b) => (a -> b) -> Scanl m a b
    [A] findIndices :: Monad m => (a -> Bool) -> Scanl m a (Maybe Int)
    [A] filtering :: Monad m => (a -> Bool) -> Scanl m a (Maybe a)
    [A] filterM :: Monad m => (a -> m Bool) -> Scanl m a r -> Scanl m a r
    [A] filter :: Monad m => (a -> Bool) -> Scanl m a r -> Scanl m a r
    [A] elemIndices :: (Monad m, Eq a) => a -> Scanl m a (Maybe Int)
    [A] droppingWhileM :: Monad m => (a -> m Bool) -> Scanl m a (Maybe a)
    [A] droppingWhile :: Monad m => (a -> Bool) -> Scanl m a (Maybe a)
    [A] dropping :: Monad m => Int -> Scanl m a (Maybe a)
    [A] drainN :: Monad m => Int -> Scanl m a ()
    [A] drainMapM :: Monad m => (a -> m b) -> Scanl m a ()
    [A] drain :: Monad m => Scanl m a ()
    [A] distribute :: Monad m => [Scanl m a b] -> Scanl m a [b]
    [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (k -> m (Maybe (Scanl m a b))) -> Scanl m a (Maybe (k, b))
    [A] demuxGenericIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (Key f -> m (Maybe (Scanl m a b))) -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] demuxGeneric :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (Key f -> m (Maybe (Scanl m a b))) -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] demux :: (Monad m, Ord k) => (a -> k) -> (k -> m (Maybe (Scanl m a b))) -> Scanl m a (Maybe (k, b))
    [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Scanl m a (Maybe a)
    [A] defaultSalt :: Int64
    [A] cumulativeScan :: Scanl m (Incr a) b -> Scanl m a b
    [A] countDistinctInt :: Monad m => Scanl m Int Int
    [A] countDistinct :: (Monad m, Ord a) => Scanl m a Int
    [A] constM :: Applicative m => m b -> Scanl m a b
    [A] const :: Applicative m => b -> Scanl m a b
    [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Scanl m a b -> Scanl m a (Maybe (k, b))
    [A] classifyGenericIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Scanl m a b -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] classifyGeneric :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Scanl m a b -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] classify :: (MonadIO m, Ord k) => (a -> k) -> Scanl m a b -> Scanl m a (Maybe (k, b))
    [A] chainStepM :: Applicative m => (s1 -> m s2) -> (a -> m (Step s2 b)) -> Step s1 a -> m (Step s2 b)
    [A] catRights :: Monad m => Scanl m b c -> Scanl m (Either a b) c
    [A] catMaybes :: Monad m => Scanl m a b -> Scanl m (Maybe a) b
    [A] catLefts :: Monad m => Scanl m a c -> Scanl m (Either a b) c
    [A] catEithers :: Scanl m a b -> Scanl m (Either a a) b
    [A] bottomBy :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> Int -> Scanl m a (MutArray a)
    [A] bottom :: (MonadIO m, Unbox a, Ord a) => Int -> Scanl m a (MutArray a)
[A] Streamly.Internal.Data.RingArray.Generic
    [A] RingArray
        [A] [ringMax] :: RingArray a -> !Int
        [A] [ringHead] :: RingArray a -> !Int
        [A] [ringArr] :: RingArray a -> MutArray a
        [A] RingArray :: MutArray a -> !Int -> !Int -> RingArray a
    [A] unsafeInsertRingWith :: RingArray a -> a -> IO Int
    [A] toStreamWith :: Int -> RingArray a -> Stream m a
    [A] toMutArray :: MonadIO m => Int -> Int -> RingArray a -> m (MutArray a)
    [A] seek :: MonadIO m => Int -> RingArray a -> m (RingArray a)
    [A] emptyOf :: MonadIO m => Int -> m (RingArray a)
    [A] createOf :: MonadIO m => Int -> Fold m a (RingArray a)
    [A] copyToMutArray :: MonadIO m => Int -> Int -> RingArray a -> m (MutArray a)
[A] Streamly.Internal.Data.RingArray
    [A] RingArray
        [A] [ringSize] :: RingArray a -> {-# UNPACK #-} !Int
        [A] [ringHead] :: RingArray a -> {-# UNPACK #-} !Int
        [A] [ringContents] :: RingArray a -> {-# UNPACK #-} !MutByteArray
        [A] RingArray :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> RingArray a
    [A] unsafeGetIndex :: forall m a. (MonadIO m, Unbox a) => Int -> RingArray a -> m a
    [A] unsafeGetHead :: (MonadIO m, Unbox a) => RingArray a -> m a
    [A] unsafeCastMutArrayWith :: forall a. Unbox a => Int -> MutArray a -> RingArray a
    [A] unsafeCastMutArray :: forall a. Unbox a => MutArray a -> RingArray a
    [A] unsafeCast :: RingArray a -> RingArray b
    [A] toMutArray :: (MonadIO m, Unbox a) => RingArray a -> m (MutArray a)
    [A] toList :: (MonadIO m, Unbox a) => RingArray a -> m [a]
    [A] showRing :: (Unbox a, Show a) => RingArray a -> IO String
    [A] scanRingsOf :: forall m a. (MonadIO m, Unbox a) => Int -> Scanl m a (RingArray a)
    [A] scanFoldRingsBy :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> Int -> Scanl m a b
    [A] scanCustomFoldRingsBy :: forall m a b. (MonadIO m, Unbox a) => (RingArray a -> m b) -> Int -> Scanl m a b
    [A] ringsOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (RingArray a)
    [A] replace_ :: forall m a. (MonadIO m, Unbox a) => RingArray a -> a -> m (RingArray a)
    [A] replace :: forall m a. (MonadIO m, Unbox a) => RingArray a -> a -> m (RingArray a, a)
    [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (RingArray a) a
    [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (RingArray a) a
    [A] readRev :: forall m a. (MonadIO m, Unbox a) => RingArray a -> Stream m a
    [A] read :: forall m a. (MonadIO m, Unbox a) => RingArray a -> Stream m a
    [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> RingArray a -> a -> m ()
    [A] moveReverse :: forall a. Unbox a => RingArray a -> RingArray a
    [A] moveForward :: forall a. Unbox a => RingArray a -> RingArray a
    [A] moveBy :: forall a. Unbox a => Int -> RingArray a -> RingArray a
    [A] modifyIndex :: Int -> RingArray a -> (a -> (a, b)) -> m b
    [A] length :: forall a. Unbox a => RingArray a -> Int
    [A] insert :: RingArray a -> a -> m (RingArray a)
    [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> RingArray a -> m (Maybe a)
    [A] foldlM' :: forall m a b. (MonadIO m, Unbox a) => (b -> a -> m b) -> b -> RingArray a -> m b
    [A] fold :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> RingArray a -> m b
    [A] eqArrayN :: RingArray a -> Array a -> Int -> IO Bool
    [A] eqArray :: RingArray a -> Array a -> IO Bool
    [A] createOfLast :: (Unbox a, MonadIO m) => Int -> Fold m a (RingArray a)
    [A] castMutArrayWith :: forall a. Unbox a => Int -> MutArray a -> Maybe (RingArray a)
    [A] castMutArray :: forall a. Unbox a => MutArray a -> Maybe (RingArray a)
    [A] cast :: forall a b. Unbox b => RingArray a -> Maybe (RingArray b)
    [A] byteLength :: RingArray a -> Int
    [A] asMutArray_ :: RingArray a -> MutArray a
    [A] asMutArray :: RingArray a -> (MutArray a, Int)
    [A] asBytes :: RingArray a -> RingArray Word8
[R] Streamly.Internal.Data.Ring.Generic
[R] Streamly.Internal.Data.Ring
[C] Streamly.Internal.Data.Producer
    [C] parse
        [O] parse :: Monad m => Parser a m b -> Producer m (Source s a) a -> Source s a -> m (Either ParseError b, Source s a)
        [N] parse :: Monad m => Parser a m b -> Producer m (Source s a) a -> Source s a -> m (Either ParseErrorPos b, Source s a)
[C] Streamly.Internal.Data.Pipe
    [C] Step
        [A] YieldP :: ps -> b -> Step cs ps b
        [A] YieldC :: cs -> b -> Step cs ps b
        [R] Yield :: a -> s -> Step s a
        [A] Stop :: Step cs ps b
        [A] SkipP :: ps -> Step cs ps b
        [A] SkipC :: cs -> Step cs ps b
        [R] Continue :: s -> Step s a
    [R] PipeState
    [C] Pipe
        [C] Pipe
            [O] Pipe :: (s1 -> a -> m (Step (PipeState s1 s2) b)) -> (s2 -> m (Step (PipeState s1 s2) b)) -> s1 -> Pipe m a b
            [N] Pipe :: (cs -> a -> m (Step cs ps b)) -> (ps -> m (Step cs ps b)) -> cs -> Pipe m a b
    [R] zipWith :: Monad m => (a -> b -> c) -> Pipe m i a -> Pipe m i b -> Pipe m i c
    [A] teeMerge :: Monad m => Pipe m a b -> Pipe m a b -> Pipe m a b
    [R] tee :: Monad m => Pipe m a b -> Pipe m a b -> Pipe m a b
    [A] scanFold :: Monad m => Fold m a b -> Pipe m a b
    [A] identity :: Monad m => Pipe m a a
    [A] fromStream :: Monad m => Stream m a -> Pipe m () a
    [A] fromScanr :: Monad m => Scanr m a b -> Pipe m a b
    [A] fromFold :: Monad m => Fold m a b -> Pipe m a b
    [A] filterM :: Monad m => (a -> m Bool) -> Pipe m a a
    [A] filter :: Monad m => (a -> Bool) -> Pipe m a a
[A] Streamly.Internal.Data.Path
    [A] class IsPath a b
    [A] GHC.Show.Show
        [A] instance GHC.Show.Show Streamly.Internal.Data.Path.PathException
    [A] GHC.Exception.Type.Exception
        [A] instance GHC.Exception.Type.Exception Streamly.Internal.Data.Path.PathException
    [A] GHC.Classes.Eq
        [A] instance GHC.Classes.Eq Streamly.Internal.Data.Path.PathException
    [A] PathException
        [A] InvalidPath :: String -> PathException
    [A] unsafeFromPath :: IsPath a b => a -> b
    [A] toPath :: IsPath a b => b -> a
    [A] fromPath :: (IsPath a b, MonadThrow m) => a -> m b
[C] Streamly.Internal.Data.ParserK
    [C] Step
        [C] Partial
            [O] Partial :: !Int -> (Input a -> m (Step a m r)) -> Step a m r
            [N] Partial :: !Int -> StepParser a m r -> Step a m r
        [C] Continue
            [O] Continue :: !Int -> (Input a -> m (Step a m r)) -> Step a m r
            [N] Continue :: !Int -> StepParser a m r -> Step a m r
    [C] ParserK
        [C] [runParser]
            [O] [runParser] :: ParserK a m b -> forall r. (ParseResult b -> Int -> Input a -> m (Step a m r)) -> Int -> Int -> Input a -> m (Step a m r)
            [N] [runParser] :: ParserK a m b -> forall r. (ParseResult b -> Int -> StepParser a m r) -> Int -> Int -> StepParser a m r
        [C] MkParser
            [O] MkParser :: (forall r. (ParseResult b -> Int -> Input a -> m (Step a m r)) -> Int -> Int -> Input a -> m (Step a m r)) -> ParserK a m b
            [N] MkParser :: (forall r. (ParseResult b -> Int -> StepParser a m r) -> Int -> Int -> StepParser a m r) -> ParserK a m b
    [A] toParserK :: Monad m => Parser a m b -> ParserK a m b
    [A] toParser :: Monad m => ParserK a m b -> Parser a m b
    [A] parserDone :: Applicative m => ParseResult b -> Int -> Input a -> m (Step a m b)
    [A] chainr1 :: ParserK b IO a -> ParserK b IO (a -> a -> a) -> ParserK b IO a
    [A] chainr :: ParserK b IO a -> ParserK b IO (a -> a -> a) -> a -> ParserK b IO a
    [A] chainl1 :: ParserK b IO a -> ParserK b IO (a -> a -> a) -> ParserK b IO a
    [A] chainl :: ParserK b IO a -> ParserK b IO (a -> a -> a) -> a -> ParserK b IO a
    [D] adaptCG :: Monad m => Parser a m b -> ParserK (Array a) m b
    [D] adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
    [D] adapt :: Monad m => Parser a m b -> ParserK a m b
[C] Streamly.Internal.Data.Parser
    [C] Step
        [A] SPartial :: !Int -> !s -> Step s b
        [A] SError :: !String -> Step s b
        [A] SDone :: !Int -> !b -> Step s b
        [A] SContinue :: !Int -> !s -> Step s b
        [R] Partial :: !Int -> !s -> Step s b
        [R] Error :: !String -> Step s b
        [R] Done :: !Int -> !b -> Step s b
        [R] Continue :: !Int -> !s -> Step s b
    [C] Parser
        [C] Parser
            [O] Parser :: (s -> a -> m (Step s b)) -> m (Initial s b) -> (s -> m (Step s b)) -> Parser a m b
            [N] Parser :: (s -> a -> m (Step s b)) -> m (Initial s b) -> (s -> m (Final s b)) -> Parser a m b
    [A] ParseErrorPos
        [A] ParseErrorPos :: Int -> String -> ParseErrorPos
    [A] Final
        [A] FError :: !String -> Final s b
        [A] FDone :: !Int -> !b -> Final s b
        [A] FContinue :: !Int -> !s -> Final s b
    [C] ParseError
    [D] takeStartBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [D] takeStartBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [C] takeEndBy_
        [O] takeEndBy_ :: (a -> Bool) -> Parser a m b -> Parser a m b
        [N] takeEndBy_ :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b
    [A] takeBeginBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [A] takeBeginBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b
    [A] mapCount :: (Int -> Int) -> Step s b -> Step s b
    [A] localReaderT :: (r -> r) -> Parser a (ReaderT r m) b -> Parser a (ReaderT r m) b
    [R] extractStep :: Monad m => (s -> m (Step s1 b)) -> Step s b -> m (Step s1 b)
    [A] bimapMorphOverrideCount :: Int -> (s -> s1) -> (b -> b1) -> Final s b -> Step s1 b1
[C] Streamly.Internal.Data.MutByteArray
    [A] unsafePutSlice :: MonadIO m => MutByteArray -> Int -> MutByteArray -> Int -> Int -> m ()
    [A] unsafePutPtrN :: MonadIO m => Ptr Word8 -> MutByteArray -> Int -> Int -> m ()
    [A] unsafePinnedCloneSlice :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray
    [A] unsafeCloneSliceAs :: MonadIO m => PinnedState -> Int -> Int -> MutByteArray -> m MutByteArray
    [A] unsafeCloneSlice :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray
    [A] unsafeByteCmp :: MutByteArray -> Int -> MutByteArray -> Int -> Int -> IO Int
    [C] unsafeAsPtr
        [O] unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b
        [N] unsafeAsPtr :: MonadIO m => MutByteArray -> (Ptr a -> IO b) -> m b
    [A] touch :: MutByteArray -> IO ()
    [D] sizeOfMutableByteArray :: MutByteArray -> IO Int
    [A] reallocSliceAs :: PinnedState -> Int -> MutByteArray -> Int -> Int -> IO MutByteArray
    [D] putSliceUnsafe :: MonadIO m => MutByteArray -> Int -> MutByteArray -> Int -> Int -> m ()
    [D] pinnedNewAlignedBytes :: Int -> Int -> IO MutByteArray
    [D] pinnedNew :: Int -> IO MutByteArray
    [D] pinnedCloneSliceUnsafe :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray
    [D] newBytesAs :: PinnedState -> Int -> IO MutByteArray
    [A] newAs :: PinnedState -> Int -> IO MutByteArray
    [A] new' :: Int -> IO MutByteArray
    [A] length :: MutByteArray -> IO Int
    [A] largeObjectThreshold :: Int
    [D] getMutableByteArray# :: MutByteArray -> MutableByteArray# RealWorld
    [A] getMutByteArray# :: MutByteArray -> MutableByteArray# RealWorld
    [D] cloneSliceUnsafeAs :: MonadIO m => PinnedState -> Int -> Int -> MutByteArray -> m MutByteArray
    [D] cloneSliceUnsafe :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray
    [A] blockSize :: Int
[C] Streamly.Internal.Data.MutArray.Generic
    [C] MutArray
        [R] [arrTrueLen] :: MutArray a -> {-# UNPACK #-} !Int
        [R] [arrLen] :: MutArray a -> {-# UNPACK #-} !Int
        [A] [arrEnd] :: MutArray a -> {-# UNPACK #-} !Int
        [A] [arrBound] :: MutArray a -> {-# UNPACK #-} !Int
    [D] writeN :: MonadIO m => Int -> Fold m a (MutArray a)
    [D] write :: MonadIO m => Fold m a (MutArray a)
    [A] unsafeSnoc :: MonadIO m => MutArray a -> a -> m (MutArray a)
    [A] unsafeSliceOffLen :: Int -> Int -> MutArray a -> MutArray a
    [A] unsafePutSlice :: MonadIO m => MutArray a -> Int -> MutArray a -> Int -> Int -> m ()
    [A] unsafePutIndex :: forall m a. MonadIO m => Int -> MutArray a -> a -> m ()
    [A] unsafeModifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
    [A] unsafeGetIndexWith :: MonadIO m => MutableArray# RealWorld a -> Int -> m a
    [A] unsafeGetIndex :: MonadIO m => Int -> MutArray a -> m a
    [D] strip :: MonadIO m => (a -> Bool) -> MutArray a -> m (MutArray a)
    [D] snocUnsafe :: MonadIO m => MutArray a -> a -> m (MutArray a)
    [A] sliceOffLen :: Int -> Int -> MutArray a -> MutArray a
    [D] putSliceUnsafe :: MonadIO m => MutArray a -> Int -> MutArray a -> Int -> Int -> m ()
    [D] putIndexUnsafe :: forall m a. MonadIO m => Int -> MutArray a -> a -> m ()
    [D] new :: MonadIO m => Int -> m (MutArray a)
    [D] modifyIndexUnsafe :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b
    [A] initializeOfFilledUpto :: MonadIO m => Int -> Int -> a -> m (MutArray a)
    [D] getSliceUnsafe :: Int -> Int -> MutArray a -> MutArray a
    [D] getSlice :: Int -> Int -> MutArray a -> MutArray a
    [D] getIndexUnsafeWith :: MonadIO m => MutableArray# RealWorld a -> Int -> m a
    [D] getIndexUnsafe :: MonadIO m => Int -> MutArray a -> m a
    [A] dropAround :: MonadIO m => (a -> Bool) -> MutArray a -> m (MutArray a)
[C] Streamly.Internal.Data.MutArray
    [R] IORef
    [D] writeNWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
    [D] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [D] writeIORef :: Unbox a => IORef a -> a -> IO ()
    [D] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
    [D] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
    [D] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
    [A] vacate :: MutArray a -> MutArray a
    [A] unsafeSplice :: MonadIO m => MutArray a -> MutArray a -> m (MutArray a)
    [A] unsafeSnoc :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
    [A] unsafeSliceOffLen :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a
    [A] unsafePutIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
    [A] unsafePokeSkip :: Int -> MutArray Word8 -> MutArray Word8
    [D] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [A] unsafePeekSkip :: Int -> MutArray Word8 -> MutArray Word8
    [A] unsafePeek :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> m (a, MutArray Word8)
    [A] unsafeModifyIndex :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
    [A] unsafeGetIndexRev :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
    [A] unsafeGetIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
    [A] unsafeCreateWithPtr' :: MonadIO m => Int -> (Ptr Word8 -> IO Int) -> m (MutArray Word8)
    [A] unsafeCreateWithOf :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
    [R] unsafeCreateOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
    [A] unsafeCreateOf' :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [A] unsafeCast :: MutArray a -> MutArray b
    [A] unsafeBreakAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
    [C] unsafeAsPtr
        [O] unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b
        [N] unsafeAsPtr :: MonadIO m => MutArray a -> (Ptr a -> Int -> IO b) -> m b
    [A] unsafeAppendPtrN :: MonadIO m => MutArray Word8 -> Ptr Word8 -> Int -> m (MutArray Word8)
    [D] unsafeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
    [A] unsafeAppendMax :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> Fold m a (MutArray a)
    [A] toMutByteArray :: MutArray a -> (MutByteArray, Int, Int)
    [D] strip :: forall a m. (Unbox a, MonadIO m) => (a -> Bool) -> MutArray a -> m (MutArray a)
    [A] splitterFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (MutArray a)
    [D] splitOn :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a)
    [A] splitEndBy_ :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a)
    [A] splitEndBy :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a)
    [D] splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
    [D] spliceUnsafe :: MonadIO m => MutArray a -> MutArray a -> m (MutArray a)
    [D] snocUnsafe :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
    [D] snocLinear :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a)
    [A] snocGrowBy :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m (MutArray a)
    [D] slicerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (MutArray a)
    [A] sliceOffLen :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a
    [D] sliceIndexerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (Int, Int)
    [A] serializePtrN :: MutArray Word8 -> Ptr a -> Int -> m (MutArray Word8)
    [A] serialize :: forall m a. (MonadIO m, Serialize a) => MutArray Word8 -> a -> m (MutArray Word8)
    [A] scanCompactMin' :: forall m a. (MonadIO m, Unbox a) => Int -> Scanl m (MutArray a) (Maybe (MutArray a))
    [A] scanCompactMin :: forall m a. (MonadIO m, Unbox a) => Int -> Scanl m (MutArray a) (Maybe (MutArray a))
    [A] revDropWhile :: forall a m. (Unbox a, MonadIO m) => (a -> Bool) -> MutArray a -> m (MutArray a)
    [A] revBreakEndBy_ :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> m (MutArray a, MutArray a)
    [A] revBreakEndBy :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> m (MutArray a, MutArray a)
    [A] reallocBytesWith :: forall m a. (MonadIO m, Unbox a) => String -> (Int -> Int) -> Int -> MutArray a -> m (MutArray a)
    [A] reallocBytes :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
    [D] realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
    [D] readIORef :: Unbox a => IORef a -> IO a
    [A] rangeBy :: (a -> a -> Ordering) -> MutArray a -> IO (Maybe (a, a))
    [D] putIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m ()
    [D] pollIntIORef :: (MonadIO m, Unbox a) => IORef a -> Stream m a
    [D] pokeSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
    [A] pokeMay :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> a -> m (Maybe (MutArray Word8))
    [D] pokeAppendMay :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> a -> m (Maybe (MutArray Word8))
    [D] pokeAppend :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> a -> m (MutArray Word8)
    [A] poke :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> a -> m (MutArray Word8)
    [D] pinnedNewAligned :: (MonadIO m, Unbox a) => Int -> Int -> m (MutArray a)
    [D] pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [D] pinnedFromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
    [D] pinnedFromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
    [D] pinnedEmptyOf :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [D] pinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [D] pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
    [D] pinnedCompactLE :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [D] pinnedClone :: MonadIO m => MutArray a -> m (MutArray a)
    [D] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
    [D] peekUnconsUnsafe :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> m (a, MutArray Word8)
    [D] peekUncons :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> m (Maybe a, MutArray Word8)
    [D] peekSkipUnsafe :: Int -> MutArray Word8 -> MutArray Word8
    [A] peek :: forall m a. (MonadIO m, Unbox a) => MutArray Word8 -> m (Maybe a, MutArray Word8)
    [D] pPinnedCompactLE :: forall m a. (MonadIO m, Unbox a) => Int -> Parser (MutArray a) m (MutArray a)
    [D] pCompactLE :: forall m a. (MonadIO m, Unbox a) => Int -> Parser (MutArray a) m (MutArray a)
    [D] newIORef :: forall a. Unbox a => a -> IO (IORef a)
    [D] newArrayWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int -> IO MutByteArray) -> Int -> Int -> m (MutArray a)
    [D] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [D] modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b
    [D] modifyIORef' :: Unbox a => IORef a -> (a -> a) -> IO ()
    [D] lPinnedCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
    [D] lCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) ()
    [A] isPower2 :: Int -> Bool
    [A] indexerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (Int, Int)
    [A] growTo :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
    [A] growBy :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
    [D] grow :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a)
    [D] getSliceUnsafe :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a
    [D] getSlice :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a
    [D] getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a
    [A] fromW16CString# :: MonadIO m => Addr# -> m (MutArray Word16)
    [A] fromMutByteArray :: MonadIO m => MutByteArray -> Int -> Int -> m (MutArray a)
    [A] fromListN' :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a)
    [A] fromList' :: (MonadIO m, Unbox a) => [a] -> m (MutArray a)
    [A] fromCString# :: MonadIO m => Addr# -> m (MutArray Word8)
    [D] fromByteStr# :: MonadIO m => Addr# -> m (MutArray Word8)
    [A] free :: forall a. Unbox a => MutArray a -> Int
    [A] foldRev :: (MonadIO m, Unbox a) => Fold m a b -> MutArray a -> m b
    [A] fold :: (MonadIO m, Unbox a) => Fold m a b -> MutArray a -> m b
    [D] fPinnedCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) (MutArray a)
    [D] fCompactGE :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) (MutArray a)
    [A] emptyWithAligned :: forall m a. (MonadIO m, Unbox a) => (Int -> Int -> IO MutByteArray) -> Int -> Int -> m (MutArray a)
    [A] emptyOf' :: (MonadIO m, Unbox a) => Int -> m (MutArray a)
    [A] dropWhile :: forall a m. (Unbox a, MonadIO m) => (a -> Bool) -> MutArray a -> m (MutArray a)
    [A] dropAround :: forall a m. (Unbox a, MonadIO m) => (a -> Bool) -> MutArray a -> m (MutArray a)
    [A] deserializePtrN :: MutArray Word8 -> (Ptr a -> Int -> m b) -> m (a, MutArray Word8)
    [A] deserialize :: (MonadIO m, Serialize a) => MutArray Word8 -> m (a, MutArray Word8)
    [A] createWithOf :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
    [D] createWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [D] createOfWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a)
    [A] createOfLast :: (Unbox a, MonadIO m) => Int -> Fold m a (MutArray a)
    [A] createOf' :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [A] createMinOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a)
    [A] createCompactMin' :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) (MutArray a)
    [A] createCompactMin :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) (MutArray a)
    [A] createCompactMax' :: forall m a. (MonadIO m, Unbox a) => Int -> Parser (MutArray a) m (MutArray a)
    [A] createCompactMax :: forall m a. (MonadIO m, Unbox a) => Int -> Parser (MutArray a) m (MutArray a)
    [A] create' :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a)
    [A] compactSepByByte_ :: MonadIO m => Word8 -> Stream m (MutArray Word8) -> Stream m (MutArray Word8)
    [D] compactOnByteSuffix :: MonadIO m => Word8 -> Stream m (MutArray Word8) -> Stream m (MutArray Word8)
    [D] compactOnByte :: MonadIO m => Word8 -> Stream m (MutArray Word8) -> Stream m (MutArray Word8)
    [A] compactMin :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [A] compactMax' :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [A] compactMax :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [D] compactLE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [D] compactGE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [A] compactExact :: Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [A] compactEndByLn_ :: MonadIO m => Stream m (MutArray Word8) -> Stream m (MutArray Word8)
    [A] compactEndByByte_ :: MonadIO m => Word8 -> Stream m (MutArray Word8) -> Stream m (MutArray Word8)
    [R] compactEQ :: Int -> Stream m (MutArray a) -> Stream m (MutArray a)
    [A] clone' :: MonadIO m => MutArray a -> m (MutArray a)
    [A] chunksOf' :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a)
    [A] chunksEndByLn' :: MonadIO m => Stream m Word8 -> Stream m (MutArray Word8)
    [A] chunksEndByLn :: MonadIO m => Stream m Word8 -> Stream m (MutArray Word8)
    [A] chunksEndBy' :: forall m a. (MonadIO m, Unbox a) => (a -> Bool) -> Stream m a -> Stream m (MutArray a)
    [A] chunksEndBy :: forall m a. (MonadIO m, Unbox a) => (a -> Bool) -> Stream m a -> Stream m (MutArray a)
    [D] castUnsafe :: MutArray a -> MutArray b
    [A] capacity :: forall a. Unbox a => MutArray a -> Int
    [D] breakOn :: MonadIO m => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
    [A] breakEndBy_ :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> m (MutArray a, MutArray a)
    [A] breakEndByWord8_ :: MonadIO m => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8))
    [A] breakEndBy :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> m (MutArray a, MutArray a)
    [A] breakAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a)
    [A] asCWString :: MutArray a -> (CWString -> IO b) -> IO b
    [A] asCString :: MutArray a -> (CString -> IO b) -> IO b
    [A] appendStreamN :: (MonadIO m, Unbox a) => Int -> MutArray a -> Stream m a -> m (MutArray a)
    [A] appendStream :: (MonadIO m, Unbox a) => MutArray a -> Stream m a -> m (MutArray a)
    [A] appendPtrN :: MonadIO m => MutArray Word8 -> Ptr Word8 -> Int -> m (MutArray Word8)
    [D] appendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a)
    [A] appendMax :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> Fold m a (MutArray a)
    [A] appendGrowBy :: (MonadIO m, Unbox a) => Int -> MutArray a -> Fold m a (MutArray a)
    [A] appendCString# :: MonadIO m => MutArray Word8 -> Addr# -> m (MutArray Word8)
    [A] appendCString :: MonadIO m => MutArray Word8 -> Ptr a -> m (MutArray Word8)
    [A] append2 :: (MonadIO m, Unbox a) => MutArray a -> Fold m a (MutArray a)
    [D] append :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a)
[A] Streamly.Internal.Data.IORef
    [A] IORef
    [A] writeIORef :: Unbox a => IORef a -> a -> IO ()
    [A] readIORef :: Unbox a => IORef a -> IO a
    [A] pollIORefInt :: MonadIO m => IORef Int -> Stream m Int
    [A] pollGenericIORef :: (MonadIO m, Unbox a) => IORef a -> Stream m a
    [A] newIORef :: forall a. Unbox a => a -> IO (IORef a)
    [A] modifyIORef' :: Unbox a => IORef a -> (a -> a) -> IO ()
[C] Streamly.Internal.Data.Fold
    [C] windowRange
        [O] windowRange :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe (a, a))
        [N] windowRange :: forall m a. (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (Maybe (a, a))
    [C] windowMinimum
        [O] windowMinimum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
        [N] windowMinimum :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (Maybe a)
    [C] windowMaximum
        [O] windowMaximum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a)
        [N] windowMaximum :: (MonadIO m, Unbox a, Ord a) => Int -> Fold m a (Maybe a)
    [R] transform :: Monad m => Pipe m a b -> Fold m b c -> Fold m a c
    [C] toContainerIO
        [O] toContainerIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (f b)
        [N] toContainerIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> Fold m a b -> Fold m a (f b)
    [C] toContainer
        [O] toContainer :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (f b)
        [N] toContainer :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> Fold m a b -> Fold m a (f b)
    [C] takeEndBySeq_
        [O] takeEndBySeq_ :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Fold m a b
        [N] takeEndBySeq_ :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Fold m a b
    [C] takeEndBySeq
        [O] takeEndBySeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Fold m a b
        [N] takeEndBySeq :: forall m a b. (MonadIO m, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Fold m a b
    [A] scanlMany :: Monad m => Scanl m a b -> Fold m b c -> Fold m a c
    [A] scanl :: Monad m => Scanl m a b -> Fold m b c -> Fold m a c
    [D] scanMaybe :: Monad m => Fold m a (Maybe b) -> Fold m b c -> Fold m a c
    [D] scanMany :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [D] scan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [A] rollingMap :: Monad m => (Maybe a -> a -> b) -> Fold m a b
    [A] rangeBy :: Monad m => (a -> a -> Ordering) -> Fold m a (Maybe (a, a))
    [A] range :: (Monad m, Ord a) => Fold m a (Maybe (a, a))
    [A] postscanlMaybe :: Monad m => Scanl m a (Maybe b) -> Fold m b c -> Fold m a c
    [A] postscanl :: Monad m => Scanl m a b -> Fold m b c -> Fold m a c
    [D] postscan :: Monad m => Fold m a b -> Fold m b c -> Fold m a c
    [A] pipe :: Monad m => Pipe m a b -> Fold m b c -> Fold m a c
    [A] onException :: MonadCatch m => m x -> Fold m a b -> Fold m a b
    [R] lengthGeneric :: (Monad m, Num b) => Fold m a b
    [D] indexingWith :: Monad m => Int -> (Int -> Int) -> Fold m a (Maybe (Int, a))
    [D] indexingRev :: Monad m => Int -> Fold m a (Maybe (Int, a))
    [D] indexing :: Monad m => Fold m a (Maybe (Int, a))
    [R] indexGeneric :: (Integral i, Monad m) => i -> Fold m a (Maybe a)
    [A] ifThen :: Monad m => m Bool -> Fold m a b -> Fold m a b -> Fold m a b
    [A] genericLength :: (Monad m, Num b) => Fold m a b
    [A] genericIndex :: (Integral i, Monad m) => i -> Fold m a (Maybe a)
    [A] fromScanl :: Scanl m a b -> Fold m a b
    [D] foldlM1' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
    [A] foldl1M' :: Monad m => (a -> a -> m a) -> Fold m a (Maybe a)
    [A] finallyIO :: (MonadIO m, MonadCatch m) => IO b -> Fold m a b -> Fold m a b
    [A] finalM :: Monad m => Fold m a b -> m b
    [D] extractM :: Monad m => Fold m a b -> m b
    [A] distributeScan :: Monad m => m [Fold m a b] -> Scanl m a [b]
    [A] demuxerToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (k -> m (Maybe (Fold m a b))) -> Fold m a (Map k b)
    [A] demuxerToMap :: (Monad m, Ord k) => (a -> k) -> (k -> m (Maybe (Fold m a b))) -> Fold m a (Map k b)
    [A] demuxerToContainerIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (Key f -> m (Maybe (Fold m a b))) -> Fold m a (f b)
    [A] demuxerToContainer :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (Key f -> m (Maybe (Fold m a b))) -> Fold m a (f b)
    [D] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
    [D] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b)
    [D] demuxToContainerIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b)
    [D] demuxToContainer :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b)
    [A] demuxScanIO :: (MonadIO m, Ord k) => (a -> k) -> (k -> m (Maybe (Fold m a b))) -> Scanl m a (Maybe (k, b))
    [A] demuxScanGenericIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (Key f -> m (Maybe (Fold m a b))) -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] demuxScanGeneric :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (Key f -> m (Maybe (Fold m a b))) -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] demuxScan :: (Monad m, Ord k) => (a -> k) -> (k -> m (Maybe (Fold m a b))) -> Scanl m a (Maybe (k, b))
    [C] demuxKvToMap
        [O] demuxKvToMap :: (Monad m, Ord k) => (k -> m (Fold m a b)) -> Fold m (k, a) (Map k b)
        [N] demuxKvToMap :: (Monad m, Ord k) => (k -> m (Maybe (Fold m a b))) -> Fold m (k, a) (Map k b)
    [C] demuxKvToContainer
        [O] demuxKvToContainer :: (Monad m, IsMap f, Traversable f) => (Key f -> m (Fold m a b)) -> Fold m (Key f, a) (f b)
        [N] demuxKvToContainer :: (Monad m, IsMap f, Traversable f) => (Key f -> m (Maybe (Fold m a b))) -> Fold m (Key f, a) (f b)
    [D] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
    [D] demuxGenericIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (m (f b), Maybe (Key f, b))
    [D] demuxGeneric :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (m (f b), Maybe (Key f, b))
    [D] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b))
    [A] classifyScanIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Scanl m a (Maybe (k, b))
    [A] classifyScanGenericIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] classifyScanGeneric :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Scanl m a (m (f b), Maybe (Key f, b))
    [A] classifyScan :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Scanl m a (Maybe (k, b))
    [D] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
    [D] classifyGenericIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (m (f b), Maybe (Key f, b))
    [D] classifyGeneric :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (m (f b), Maybe (Key f, b))
    [D] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b))
    [A] bracketIO :: (MonadIO m, MonadCatch m) => IO x -> (x -> IO c) -> (x -> Fold m a b) -> Fold m a b
    [A] before :: Monad m => m x -> Fold m a b -> Fold m a b
[A] Streamly.Internal.Data.CString
    [A] splicePtrN :: MutByteArray -> Ptr Word8 -> Int -> IO Int
    [A] spliceCString :: MutByteArray -> CString -> IO Int
    [A] splice :: MutByteArray -> MutByteArray -> IO Int
    [A] putCString :: MutByteArray -> Int -> CString -> IO Int
    [A] length :: MutByteArray -> IO Int
[C] Streamly.Internal.Data.Array.Generic
    [C] Array
        [R] [arrLen] :: Array a -> {-# UNPACK #-} !Int
        [A] [arrEnd] :: Array a -> {-# UNPACK #-} !Int
    [R] GHC.Show.Show
    [R] GHC.Read.Read
    [R] GHC.Classes.Ord
    [R] GHC.Classes.Eq
    [R] writeWith :: MonadIO m => Int -> Fold m a (Array a)
    [D] writeN :: MonadIO m => Int -> Fold m a (Array a)
    [R] writeLastN :: MonadIO m => Int -> Fold m a (Array a)
    [D] write :: MonadIO m => Fold m a (Array a)
    [A] unsafeThaw :: Array a -> MutArray a
    [A] unsafeSliceOffLen :: Int -> Int -> Array a -> Array a
    [A] unsafeGetIndex :: Int -> Array a -> a
    [A] unsafeFreeze :: MutArray a -> Array a
    [A] toParserK :: Monad m => Parser a m b -> ParserK (Array a) m b
    [D] strip :: (a -> Bool) -> Array a -> Array a
    [A] parsePos :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b)
    [A] parseBreakPos :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b, StreamK m (Array a))
    [A] parseBreak :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] parse :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [D] getSliceUnsafe :: Int -> Int -> Array a -> Array a
    [D] getIndexUnsafe :: Int -> Array a -> a
    [A] fromCString# :: MonadIO m => Addr# -> m (Array Word8)
    [D] fromByteStr# :: Addr# -> Array Word8
    [A] dropAround :: (a -> Bool) -> Array a -> Array a
    [A] createWith :: MonadIO m => Int -> Fold m a (Array a)
    [A] createOfLast :: MonadIO m => Int -> Fold m a (Array a)
[C] Streamly.Internal.Data.Array
    [D] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [D] writeLastN :: (Unbox a, MonadIO m) => Int -> Fold m a (Array a)
    [D] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
    [A] unsnoc :: Unbox a => Array a -> Maybe (Array a, a)
    [A] unsafeSliceOffLen :: forall a. Unbox a => Int -> Int -> Array a -> Array a
    [A] unsafeReader :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
    [D] unsafePinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [C] unsafePinnedAsPtr
        [O] unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> m b) -> m b
        [N] unsafePinnedAsPtr :: MonadIO m => Array a -> (Ptr a -> Int -> IO b) -> m b
    [D] unsafeIndexIO :: forall a. Unbox a => Int -> Array a -> IO a
    [A] unsafeGetIndexRevIO :: forall a. Unbox a => Int -> Array a -> IO a
    [A] unsafeGetIndexRev :: forall a. Unbox a => Int -> Array a -> a
    [A] unsafeGetIndexIO :: forall a. Unbox a => Int -> Array a -> IO a
    [A] unsafeGetIndex :: forall a. Unbox a => Int -> Array a -> a
    [A] unsafeFromForeignPtr :: MonadIO m => ForeignPtr Word8 -> Int -> m (Array Word8)
    [A] unsafeCreateOf' :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [A] unsafeCast :: Array a -> Array b
    [A] unsafeBreakAt :: Unbox a => Int -> Array a -> (Array a, Array a)
    [A] unsafeAsForeignPtr :: MonadIO m => Array a -> (ForeignPtr a -> Int -> IO b) -> m b
    [A] uncons :: Unbox a => Array a -> Maybe (a, Array a)
    [A] toParserK :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b
    [A] tail :: Unbox a => Array a -> Array a
    [A] splitterFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Array a)
    [D] splitOn :: (Monad m, Unbox a) => (a -> Bool) -> Array a -> Stream m (Array a)
    [A] splitEndBy_ :: (Monad m, Unbox a) => (a -> Bool) -> Array a -> Stream m (Array a)
    [A] splitEndBy :: (MonadIO m, Unbox a) => (a -> Bool) -> Array a -> Stream m (Array a)
    [D] splitAt :: Unbox a => Int -> Array a -> (Array a, Array a)
    [D] slicerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Array a)
    [D] sliceIndexerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Int, Int)
    [A] serialize' :: Serialize a => a -> Array Word8
    [A] scanCompactMin' :: forall m a. (MonadIO m, Unbox a) => Int -> Scanl m (Array a) (Maybe (Array a))
    [A] scanCompactMin :: forall m a. (MonadIO m, Unbox a) => Int -> Scanl m (Array a) (Maybe (Array a))
    [A] revDropWhile :: Unbox a => (a -> Bool) -> Array a -> Array a
    [A] revBreakEndBy_ :: Unbox a => (a -> Bool) -> Array a -> (Array a, Array a)
    [A] revBreakEndBy :: Unbox a => (a -> Bool) -> Array a -> (Array a, Array a)
    [D] readerUnsafe :: forall m a. (Monad m, Unbox a) => Unfold m (Array a) a
    [D] pinnedSerialize :: Serialize a => a -> Array Word8
    [D] pinnedFromListN :: Unbox a => Int -> [a] -> Array a
    [D] pinnedFromList :: Unbox a => [a] -> Array a
    [D] pinnedCreateOf :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [D] pinnedCreate :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
    [D] pinnedCompactLE :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
    [R] pinnedClone :: MonadIO m => Array a -> m (Array a)
    [D] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
    [A] parsePos :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b)
    [A] parseBreakPos :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseErrorPos b, StreamK m (Array a))
    [R] parseBreakChunksK :: forall m a b. (MonadIO m, Unbox a) => Parser a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] parseBreak :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a))
    [A] parse :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b)
    [A] listEq :: (Unbox a, Ord a) => [a] -> Array a -> Bool
    [A] listCmp :: (Unbox a, Ord a) => [a] -> Array a -> Ordering
    [D] lPinnedCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) () -> Fold m (Array a) ()
    [D] lCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) () -> Fold m (Array a) ()
    [D] interposeSuffix :: forall m a. (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
    [D] interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
    [D] intercalateSuffix :: (Monad m, Unbox a) => Array a -> Stream m (Array a) -> Stream m a
    [A] init :: Unbox a => Array a -> Array a
    [A] indexerFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (Array a) (Int, Int)
    [A] head :: Unbox a => Array a -> Maybe a
    [D] getSliceUnsafe :: forall a. Unbox a => Int -> Int -> Array a -> Array a
    [D] getIndexUnsafe :: forall a. Unbox a => Int -> Array a -> a
    [A] fromW16CString# :: MonadIO m => Addr# -> m (Array Word16)
    [A] fromW16CString :: MonadIO m => Ptr Word8 -> m (Array Word16)
    [C] fromPtrN
        [O] fromPtrN :: Int -> Ptr Word8 -> Array Word8
        [N] fromPtrN :: MonadIO m => Int -> Ptr Word8 -> m (Array Word8)
    [A] fromListN' :: Unbox a => Int -> [a] -> Array a
    [A] fromList' :: Unbox a => [a] -> Array a
    [A] fromCString# :: MonadIO m => Addr# -> m (Array Word8)
    [A] fromCString :: MonadIO m => Ptr Word8 -> m (Array Word8)
    [D] fromByteStr# :: Addr# -> Array Word8
    [D] fromByteStr :: Ptr Word8 -> Array Word8
    [A] foldRev :: Unbox a => Fold Identity a b -> Array a -> b
    [A] foldM :: (Monad m, Unbox a) => Fold m a b -> Array a -> m b
    [D] foldBreakChunksK :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> StreamK m (Array a) -> m (b, StreamK m (Array a))
    [A] foldBreak :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> StreamK m (Array a) -> m (b, StreamK m (Array a))
    [D] fold :: (Monad m, Unbox a) => Fold m a b -> Array a -> m b
    [D] fPinnedCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
    [D] fCompactGE :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
    [A] dropWhile :: Unbox a => (a -> Bool) -> Array a -> Array a
    [A] dropAround :: Unbox a => (a -> Bool) -> Array a -> Array a
    [C] deserialize
        [O] deserialize :: Serialize a => Array Word8 -> a
        [N] deserialize :: Serialize a => Array Word8 -> (a, Array Word8)
    [A] createOfLast :: (Unbox a, MonadIO m) => Int -> Fold m a (Array a)
    [A] createOf' :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a)
    [A] createCompactMin' :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
    [A] createCompactMin :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) (Array a)
    [A] create' :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a)
    [A] concatSepBy :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
    [A] concatEndBySeq :: (Monad m, Unbox a) => Array a -> Stream m (Array a) -> Stream m a
    [A] concatEndBy :: forall m a. (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a
    [A] compactSepByByte_ :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
    [D] compactOnByteSuffix :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
    [D] compactOnByte :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
    [A] compactMin :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
    [A] compactMax' :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
    [A] compactMax :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
    [D] compactLE :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
    [D] compactGE :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a)
    [A] compactEndByLn_ :: MonadIO m => Stream m (Array Word8) -> Stream m (Array Word8)
    [A] compactEndByByte_ :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8)
    [R] clone :: MonadIO m => Array a -> m (Array a)
    [A] chunksOf' :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a)
    [A] chunksEndByLn' :: MonadIO m => Stream m Word8 -> Stream m (Array Word8)
    [A] chunksEndByLn :: MonadIO m => Stream m Word8 -> Stream m (Array Word8)
    [A] chunksEndBy' :: forall m a. (MonadIO m, Unbox a) => (a -> Bool) -> Stream m a -> Stream m (Array a)
    [A] chunksEndBy :: forall m a. (MonadIO m, Unbox a) => (a -> Bool) -> Stream m a -> Stream m (Array a)
    [D] castUnsafe :: Array a -> Array b
    [D] breakOn :: MonadIO m => Word8 -> Array Word8 -> m (Array Word8, Maybe (Array Word8))
    [A] breakEndBy_ :: Unbox a => (a -> Bool) -> Array a -> (Array a, Array a)
    [A] breakEndByWord8_ :: MonadIO m => Word8 -> Array Word8 -> m (Array Word8, Maybe (Array Word8))
    [A] breakEndBy :: Unbox a => (a -> Bool) -> Array a -> (Array a, Array a)
    [A] breakAt :: Unbox a => Int -> Array a -> (Array a, Array a)
    [A] asCWString :: Array a -> (CWString -> IO b) -> IO b
[C] Streamly.Internal.Control.Exception
    [A] Priority
        [A] Priority2 :: Priority
        [A] Priority1 :: Priority
    [A] GHC.Show.Show
        [A] instance GHC.Show.Show Streamly.Internal.Control.Exception.Priority
    [A] AcquireIO
        [A] AcquireIO :: (forall b c. Priority -> IO b -> (b -> IO c) -> IO (b, IO ())) -> AcquireIO
    [A] withAcquireIO :: (MonadIO m, MonadMask m) => (AcquireIO -> m a) -> m a
    [A] releaser :: MonadIO m => IORef (a, IntMap (IO b), IntMap (IO b)) -> m ()
    [A] registerWith :: Priority -> AcquireIO -> IO () -> IO ()
    [A] register :: AcquireIO -> IO () -> IO ()
    [A] hook :: AcquireIO -> IO () -> IO (IO ())
    [A] allocator :: MonadIO m => IORef (Int, IntMap (IO ()), IntMap (IO ())) -> Priority -> IO a -> (a -> IO b) -> m (a, m ())
    [A] acquire_ :: AcquireIO -> IO b -> (b -> IO c) -> IO b
    [A] acquireWith :: Priority -> AcquireIO -> IO b -> (b -> IO c) -> IO (b, IO ())
    [A] acquire :: AcquireIO -> IO b -> (b -> IO c) -> IO (b, IO ())