--------------------------------- API Annotations --------------------------------- [A] : Added [R] : Removed [C] : Changed [O] : Old definition [N] : New definition [D] : Deprecated --------------------------------- API diff --------------------------------- [C] Streamly.Unicode.Parser [A] double :: Monad m => Parser Char m Double [C] Streamly.FileSystem.Handle [A] readWith :: MonadIO m => Int -> Handle -> Stream m Word8 [A] readChunksWith :: MonadIO m => Int -> Handle -> Stream m (Array Word8) [C] Streamly.FileSystem.Dir [C] readEither [O] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath) [N] readEither :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath) [C] read [O] read :: MonadIO m => FilePath -> Stream m FilePath [N] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath [C] Streamly.Data.Unfold [A] class Enum a => Enumerable a [A] second :: b -> Unfold m (a, b) c -> Unfold m a c [A] first :: a -> Unfold m (a, b) c -> Unfold m b c [A] enumerateFromTo :: (Enumerable a, Monad m) => Unfold m (a, a) a [A] enumerateFromThenTo :: (Enumerable a, Monad m) => Unfold m (a, a, a) a [A] enumerateFromThen :: (Enumerable a, Monad m) => Unfold m (a, a) a [A] enumerateFrom :: (Enumerable a, Monad m) => Unfold m a a [C] Streamly.Data.StreamK [C] parseChunks [O] parseChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b) [N] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b) [C] parseBreakChunks [O] parseBreakChunks :: (Monad m, Unbox a) => ParserK a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [N] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [A] parseBreak :: forall m a b. Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b, StreamK m a) [A] parse :: Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b) [A] handle :: (MonadCatch m, Exception e) => (e -> m (StreamK m a)) -> StreamK m a -> StreamK m a [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> StreamK m a) -> StreamK m a [C] Streamly.Data.Stream [A] wordsBy :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [A] splitOn :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [C] handle [O] handle :: (MonadCatch m, Exception e) => (e -> Stream m a) -> Stream m a -> Stream m a [N] handle :: (MonadCatch m, Exception e) => (e -> m (Stream m a)) -> Stream m a -> Stream m a [A] groupsOf :: Monad m => Int -> Fold m a b -> Stream m a -> Stream m b [C] Streamly.Data.ParserK [D] fromParser :: (MonadIO m, Unbox a) => Parser a m b -> ParserK (Array a) m b [D] fromFold :: (MonadIO m, Unbox a) => Fold m a b -> ParserK (Array a) m b [A] adaptCG :: Monad m => Parser a m b -> ParserK (Array a) m b [A] adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b [A] adapt :: Monad m => Parser a m b -> ParserK a m b [C] Streamly.Data.Parser [A] groupByRollingEither :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (Either b c) [A] groupByRolling :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b [A] Streamly.Data.MutByteArray [A] class Unbox a [A] class Serialize a [A] SerializeConfig [A] MutByteArray [A] unpin :: MutByteArray -> IO MutByteArray [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int [A] serializeAt :: Serialize a => Int -> MutByteArray -> a -> IO Int [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO () [A] pinnedNew :: Int -> IO MutByteArray [A] pin :: MutByteArray -> IO MutByteArray [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a [A] new :: Int -> IO MutByteArray [A] isPinned :: MutByteArray -> Bool [A] inlineSerializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig [A] inlineDeserializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig [A] inlineAddSizeTo :: Maybe Inline -> SerializeConfig -> SerializeConfig [A] deserializeAt :: Serialize a => Int -> MutByteArray -> Int -> IO (Int, a) [A] deriveUnbox :: Q [Dec] -> Q [Dec] [A] deriveSerializeWith :: (SerializeConfig -> SerializeConfig) -> Q [Dec] -> Q [Dec] [A] deriveSerialize :: Q [Dec] -> Q [Dec] [A] addSizeTo :: Serialize a => Int -> a -> Int [C] Streamly.Data.MutArray.Generic [A] write :: MonadIO m => Fold m a (MutArray a) [A] readRev :: MonadIO m => MutArray a -> Stream m a [A] read :: MonadIO m => MutArray a -> Stream m a [A] putIndexUnsafe :: forall m a. MonadIO m => Int -> MutArray a -> a -> m () [A] modifyIndexUnsafe :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b [A] length :: MutArray a -> Int [A] getIndexUnsafe :: MonadIO m => Int -> MutArray a -> m a [C] getIndex [O] getIndex :: MonadIO m => Int -> MutArray a -> m a [N] getIndex :: MonadIO m => Int -> MutArray a -> m (Maybe a) [A] fromListN :: MonadIO m => Int -> [a] -> m (MutArray a) [A] fromList :: MonadIO m => [a] -> m (MutArray a) [C] Streamly.Data.MutArray [A] unpin :: MutArray a -> IO (MutArray a) [A] readRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a [A] read :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a [A] putIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m () [D] pokeByteIndex :: Unbox a => Int -> MutByteArray -> a -> IO () [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO () [A] pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) [A] pin :: MutArray a -> IO (MutArray a) [D] peekByteIndex :: Unbox a => Int -> MutByteArray -> IO a [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a [D] newPinned :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) [A] modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b [A] modifyIndex :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b [A] modify :: forall m a. (MonadIO m, Unbox a) => MutArray a -> (a -> a) -> m () [A] isPinned :: MutArray a -> Bool [A] getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a [C] getIndex [O] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a [N] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (Maybe a) [C] Streamly.Data.Array.Generic [A] toList :: Array a -> [a] [A] getIndex :: Int -> Array a -> Maybe a [C] Streamly.Data.Array [A] unpin :: Array a -> IO (Array a) [D] pokeByteIndex :: Unbox a => Int -> MutByteArray -> a -> IO () [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO () [A] pin :: Array a -> IO (Array a) [D] peekByteIndex :: Unbox a => Int -> MutByteArray -> IO a [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a [A] isPinned :: Array a -> Bool [C] Streamly.Console.Stdio --------------------------------- Internal API diff --------------------------------- [C] Streamly.Internal.Unicode.Stream [C] writeCharUtf8' [O] writeCharUtf8' :: Monad m => Fold m Word8 Char [N] writeCharUtf8' :: Monad m => Parser Word8 m Char [C] Streamly.Internal.Unicode.Parser [A] number :: Monad m => Parser Char m (Integer, Int) [A] mkDouble :: Integer -> Int -> Double [A] doubleParser :: Monad m => Parser Char m (Int, Int) [C] double [O] double :: Parser Char m Double [N] double :: Monad m => Parser Char m Double [R] Streamly.Internal.Serialize.ToBytes [R] Streamly.Internal.Serialize.FromBytes [C] Streamly.Internal.FileSystem.File [A] writeAppendWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m Word8 -> m () [A] writeAppendChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m () [A] writeAppendArray :: FilePath -> Array a -> IO () [A] writeAppend :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8 -> m () [R] appendWith :: (MonadIO m, MonadCatch m) => Int -> FilePath -> Stream m Word8 -> m () [R] appendChunks :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Array a) -> m () [R] appendArray :: FilePath -> Array a -> IO () [R] append :: (MonadIO m, MonadCatch m) => FilePath -> Stream m Word8 -> m () [C] Streamly.Internal.FileSystem.Dir [C] reader [O] reader :: MonadIO m => Unfold m FilePath FilePath [N] reader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath [C] readFiles [O] readFiles :: MonadIO m => FilePath -> Stream m FilePath [N] readFiles :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath [C] readEitherPaths [O] readEitherPaths :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath) [N] readEitherPaths :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath) [C] readEither [O] readEither :: MonadIO m => FilePath -> Stream m (Either FilePath FilePath) [N] readEither :: (MonadIO m, MonadCatch m) => FilePath -> Stream m (Either FilePath FilePath) [C] readDirs [O] readDirs :: MonadIO m => FilePath -> Stream m FilePath [N] readDirs :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath [C] read [O] read :: MonadIO m => FilePath -> Stream m FilePath [N] read :: (MonadIO m, MonadCatch m) => FilePath -> Stream m FilePath [C] fileReader [O] fileReader :: MonadIO m => Unfold m FilePath FilePath [N] fileReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath [C] eitherReaderPaths [O] eitherReaderPaths :: MonadIO m => Unfold m FilePath (Either FilePath FilePath) [N] eitherReaderPaths :: (MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath) [C] eitherReader [O] eitherReader :: MonadIO m => Unfold m FilePath (Either FilePath FilePath) [N] eitherReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath (Either FilePath FilePath) [C] dirReader [O] dirReader :: MonadIO m => Unfold m FilePath FilePath [N] dirReader :: (MonadIO m, MonadCatch m) => Unfold m FilePath FilePath [R] Streamly.Internal.Data.Unfold.Type [R] Streamly.Internal.Data.Unfold.Enumeration [C] Streamly.Internal.Data.Unfold [C] Unfold [A] Unfold :: (s -> m (Step s b)) -> (a -> m s) -> Unfold m a b [A] takeWhileMWithInput :: Monad m => (a -> b -> m Bool) -> Unfold m a b -> Unfold m a b [A] manyInterleave :: Monad m => Unfold m a b -> Unfold m c a -> Unfold m c b [A] enumerateFromStepIntegral :: (Monad m, Integral a) => Unfold m (a, a) a [A] crossApplySnd :: Unfold m a b -> Unfold m a c -> Unfold m a c [A] crossApplyFst :: Unfold m a b -> Unfold m a c -> Unfold m a b [A] concatMap :: Monad m => (b -> Unfold m a c) -> Unfold m a b -> Unfold m a c [R] Streamly.Internal.Data.Unboxed [C] Streamly.Internal.Data.Time.Units [R] Streamly.Internal.Data.Unboxed.Unbox [A] Streamly.Internal.Data.Unbox.Unbox [A] instance Streamly.Internal.Data.Unbox.Unbox Streamly.Internal.Data.Time.Units.NanoSecond64 [A] instance Streamly.Internal.Data.Unbox.Unbox Streamly.Internal.Data.Time.Units.MilliSecond64 [A] instance Streamly.Internal.Data.Unbox.Unbox Streamly.Internal.Data.Time.Units.MicroSecond64 [R] Streamly.Internal.Data.Time.Clock.Type [A] Streamly.Internal.Data.StreamK [A] CrossStreamK [A] (FixityR,6) [A] (FixityR,6) [A] (FixityR,6) [A] (FixityR,5) [A] (FixityR,5) [A] (FixityR,6) [A] (FixityR,5) [A] StreamK [A] MkStream :: (forall r. State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> m r) -> StreamK m a [A] zipWithM :: Monad m => (a -> b -> m c) -> StreamK m a -> StreamK m b -> StreamK m c [A] zipWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c [A] unfoldrMWith :: Monad m => (m a -> StreamK m a -> StreamK m a) -> (b -> m (Maybe (a, b))) -> b -> StreamK m a [A] unfoldrM :: Monad m => (b -> m (Maybe (a, b))) -> b -> StreamK m a [A] unfoldr :: (b -> Maybe (a, b)) -> b -> StreamK m a [A] uncons :: Applicative m => StreamK m a -> m (Maybe (a, StreamK m a)) [A] unShare :: StreamK m a -> StreamK m a [A] unCross :: CrossStreamK m a -> StreamK m a [A] toStream :: Applicative m => StreamK m a -> Stream m a [A] toList :: Monad m => StreamK m a -> m [a] [A] the :: (Eq a, Monad m) => StreamK m a -> m (Maybe a) [A] takeWhile :: (a -> Bool) -> StreamK m a -> StreamK m a [A] take :: Int -> StreamK m a -> StreamK m a [A] tail :: Applicative m => StreamK m a -> m (Maybe (StreamK m a)) [A] sortBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> StreamK m a [A] sequence :: Monad m => StreamK m (m a) -> StreamK m a [A] scanlx' :: (x -> a -> x) -> x -> (x -> b) -> StreamK m a -> StreamK m b [A] scanl' :: (b -> a -> b) -> b -> StreamK m a -> StreamK m b [A] reverse :: StreamK m a -> StreamK m a [A] replicateMWith :: (m a -> StreamK m a -> StreamK m a) -> Int -> m a -> StreamK m a [A] replicateM :: Monad m => Int -> m a -> StreamK m a [A] replicate :: Int -> a -> StreamK m a [A] repeatMWith :: (m a -> t m a -> t m a) -> m a -> t m a [A] repeatM :: Monad m => m a -> StreamK m a [A] repeat :: a -> StreamK m a [A] parseDBreak :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseError b, StreamK m a) [A] parseD :: Monad m => Parser a m b -> StreamK m a -> m (Either ParseError b) [A] parseChunksGeneric :: Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b) [A] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b) [A] parseBreakChunksGeneric :: forall m a b. Monad m => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [A] parseBreak :: forall m a b. Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b, StreamK m a) [A] parse :: Monad m => ParserK a m b -> StreamK m a -> m (Either ParseError b) [A] null :: Monad m => StreamK m a -> m Bool [A] notElem :: (Monad m, Eq a) => a -> StreamK m a -> m Bool [A] nilM :: Applicative m => m b -> StreamK m a [A] nil :: StreamK m a [A] mkStream :: (forall r. State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> m r) -> StreamK m a [A] mkCross :: StreamK m a -> CrossStreamK m a [A] minimumBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> m (Maybe a) [A] minimum :: (Monad m, Ord a) => StreamK m a -> m (Maybe a) [A] mfix :: Monad m => (m a -> StreamK m a) -> StreamK m a [A] mergeMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b [A] mergeIterateWith :: (StreamK m a -> StreamK m a -> StreamK m a) -> (a -> StreamK m a) -> StreamK m a -> StreamK m a [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> StreamK m a -> StreamK m a -> StreamK m a [A] mergeBy :: (a -> a -> Ordering) -> StreamK m a -> StreamK m a -> StreamK m a [A] maximumBy :: Monad m => (a -> a -> Ordering) -> StreamK m a -> m (Maybe a) [A] maximum :: (Monad m, Ord a) => StreamK m a -> m (Maybe a) [A] mapMaybe :: (a -> Maybe b) -> StreamK m a -> StreamK m b [A] mapM_ :: Monad m => (a -> m b) -> StreamK m a -> m () [A] mapMWith :: (m b -> StreamK m b -> StreamK m b) -> (a -> m b) -> StreamK m a -> StreamK m b [A] mapMSerial :: Monad m => (a -> m b) -> StreamK m a -> StreamK m b [A] mapM :: Monad m => (a -> m b) -> StreamK m a -> StreamK m b [A] map :: (a -> b) -> StreamK m a -> StreamK m b [A] lookup :: (Monad m, Eq a) => a -> StreamK m (a, b) -> m (Maybe b) [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => StreamK m a -> StreamK (t m) a [A] last :: Monad m => StreamK m a -> m (Maybe a) [A] iterateMWith :: Monad m => (m a -> StreamK m a -> StreamK m a) -> (a -> m a) -> m a -> StreamK m a [A] iterateM :: Monad m => (a -> m a) -> m a -> StreamK m a [A] iterate :: (a -> a) -> a -> StreamK m a [A] intersperseM :: Monad m => m a -> StreamK m a -> StreamK m a [A] intersperse :: Monad m => a -> StreamK m a -> StreamK m a [A] interleaveMin :: StreamK m a -> StreamK m a -> StreamK m a [A] interleaveFst :: StreamK m a -> StreamK m a -> StreamK m a [A] interleave :: StreamK m a -> StreamK m a -> StreamK m a [A] insertBy :: (a -> a -> Ordering) -> a -> StreamK m a -> StreamK m a [A] init :: Applicative m => StreamK m a -> m (Maybe (StreamK m a)) [A] hoist :: (Monad m, Monad n) => (forall x. m x -> n x) -> StreamK m a -> StreamK n a [A] head :: Monad m => StreamK m a -> m (Maybe a) [A] handle :: (MonadCatch m, Exception e) => (e -> m (StreamK m a)) -> StreamK m a -> StreamK m a [A] fromYieldK :: YieldK m a -> StreamK m a [A] fromStream :: Monad m => Stream m a -> StreamK m a [A] fromStopK :: StopK m -> StreamK m a [A] fromPure :: a -> StreamK m a [A] fromList :: [a] -> StreamK m a [A] fromIndicesMWith :: (m a -> StreamK m a -> StreamK m a) -> (Int -> m a) -> StreamK m a [A] fromIndicesM :: Monad m => (Int -> m a) -> StreamK m a [A] fromIndices :: (Int -> a) -> StreamK m a [A] fromFoldableM :: (Foldable f, Monad m) => f (m a) -> StreamK m a [A] fromFoldable :: Foldable f => f a -> StreamK m a [A] fromEffect :: Monad m => m a -> StreamK m a [A] foldrT :: (Monad m, Monad (s m), MonadTrans s) => (a -> s m b -> s m b) -> s m b -> StreamK m a -> s m b [A] foldrSShared :: (a -> StreamK m b -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b [A] foldrSM :: Monad m => (m a -> StreamK m b -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b [A] foldrS :: (a -> StreamK m b -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b [A] foldrM :: (a -> m b -> m b) -> m b -> StreamK m a -> m b [A] foldr1 :: Monad m => (a -> a -> a) -> StreamK m a -> m (Maybe a) [A] foldr :: Monad m => (a -> b -> b) -> b -> StreamK m a -> m b [A] foldlx' :: forall m a b x. Monad m => (x -> a -> x) -> x -> (x -> b) -> StreamK m a -> m b [A] foldlT :: (Monad m, Monad (s m), MonadTrans s) => (s m b -> a -> s m b) -> s m b -> StreamK m a -> s m b [A] foldlS :: (StreamK m b -> a -> StreamK m b) -> StreamK m b -> StreamK m a -> StreamK m b [A] foldlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> StreamK m a -> m b [A] foldlM' :: Monad m => (b -> a -> m b) -> m b -> StreamK m a -> m b [A] foldl' :: Monad m => (b -> a -> b) -> b -> StreamK m a -> m b [A] foldStreamShared :: State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> StreamK m a -> m r [A] foldStream :: State StreamK m a -> (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> StreamK m a -> m r [A] foldEither :: Monad m => Fold m a b -> StreamK m a -> m (Either (Fold m a b) (b, StreamK m a)) [A] foldConcat :: Monad m => Producer m a b -> Fold m b c -> StreamK m a -> m (c, StreamK m a) [A] foldBreak :: Monad m => Fold m a b -> StreamK m a -> m (b, StreamK m a) [A] fold :: Monad m => Fold m a b -> StreamK m a -> m b [A] findM :: Monad m => (a -> m Bool) -> StreamK m a -> m (Maybe a) [A] findIndices :: (a -> Bool) -> StreamK m a -> StreamK m Int [A] find :: Monad m => (a -> Bool) -> StreamK m a -> m (Maybe a) [A] filter :: (a -> Bool) -> StreamK m a -> StreamK m a [A] evalStateT :: Monad m => m s -> StreamK (StateT s m) a -> StreamK m a [A] elem :: (Monad m, Eq a) => a -> StreamK m a -> m Bool [A] dropWhile :: (a -> Bool) -> StreamK m a -> StreamK m a [A] drop :: Int -> StreamK m a -> StreamK m a [A] drain :: Monad m => StreamK m a -> m () [A] deleteBy :: (a -> a -> Bool) -> a -> StreamK m a -> StreamK m a [A] crossWith :: Monad m => (a -> b -> c) -> StreamK m a -> StreamK m b -> StreamK m c [A] crossApplyWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m (a -> b) -> StreamK m a -> StreamK m b [A] crossApplySnd :: StreamK m a -> StreamK m b -> StreamK m b [A] crossApplyFst :: StreamK m a -> StreamK m b -> StreamK m a [A] crossApply :: StreamK m (a -> b) -> StreamK m a -> StreamK m b [A] cross :: Monad m => StreamK m a -> StreamK m b -> StreamK m (a, b) [A] consMBy :: Monad m => (StreamK m a -> StreamK m a -> StreamK m a) -> m a -> StreamK m a -> StreamK m a [A] consM :: Monad m => m a -> StreamK m a -> StreamK m a [A] consK :: YieldK m a -> StreamK m a -> StreamK m a [A] cons :: a -> StreamK m a -> StreamK m a [A] conjoin :: Monad m => StreamK m a -> StreamK m a -> StreamK m a [A] concatMapWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m a -> StreamK m b [A] concatMapEffect :: Monad m => (b -> StreamK m a) -> m b -> StreamK m a [A] concatMap :: (a -> StreamK m b) -> StreamK m a -> StreamK m b [A] concatIterateWith :: (StreamK m a -> StreamK m a -> StreamK m a) -> (a -> StreamK m a) -> StreamK m a -> StreamK m a [A] concatIterateScanWith :: Monad m => (StreamK m a -> StreamK m a -> StreamK m a) -> (b -> a -> m (b, StreamK m a)) -> m b -> StreamK m a -> StreamK m a [A] concatIterateLeftsWith :: b ~ Either a c => (StreamK m b -> StreamK m b -> StreamK m b) -> (a -> StreamK m b) -> StreamK m b -> StreamK m b [A] concatEffect :: Monad m => m (StreamK m a) -> StreamK m a [A] buildSM :: Monad m => ((m a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a [A] buildS :: ((a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a [A] buildM :: Monad m => (forall r. (a -> StreamK m a -> m r) -> (a -> m r) -> m r -> m r) -> StreamK m a [A] build :: forall m a. (forall b. (a -> b -> b) -> b -> b) -> StreamK m a [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> StreamK m a) -> StreamK m a [A] bindWith :: (StreamK m b -> StreamK m b -> StreamK m b) -> StreamK m a -> (a -> StreamK m b) -> StreamK m b [A] before :: Monad m => m b -> StreamK m a -> StreamK m a [A] augmentSM :: Monad m => ((m a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a [A] augmentS :: ((a -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a) -> StreamK m a -> StreamK m a [A] append :: StreamK m a -> StreamK m a -> StreamK m a [A] any :: Monad m => (a -> Bool) -> StreamK m a -> m Bool [A] all :: Monad m => (a -> Bool) -> StreamK m a -> m Bool [A] (.:) :: a -> StreamK m a -> StreamK m a [A] (!!) :: Monad m => StreamK m a -> Int -> m (Maybe a) [R] Streamly.Internal.Data.Stream.StreamK.Type [R] Streamly.Internal.Data.Stream.StreamK.Transformer [R] Streamly.Internal.Data.Stream.StreamK [R] Streamly.Internal.Data.Stream.StreamD.Type [R] Streamly.Internal.Data.Stream.StreamD.Transformer [R] Streamly.Internal.Data.Stream.StreamD.Transform [R] Streamly.Internal.Data.Stream.StreamD.Top [R] Streamly.Internal.Data.Stream.StreamD.Step [R] Streamly.Internal.Data.Stream.StreamD.Nesting [R] Streamly.Internal.Data.Stream.StreamD.Lift [R] Streamly.Internal.Data.Stream.StreamD.Generate [R] Streamly.Internal.Data.Stream.StreamD.Exception [R] Streamly.Internal.Data.Stream.StreamD.Eliminate [R] Streamly.Internal.Data.Stream.StreamD.Container [D] Streamly.Internal.Data.Stream.StreamD [R] Streamly.Internal.Data.Stream.Common [R] Streamly.Internal.Data.Stream.Chunked [C] Streamly.Internal.Data.Stream [A] class Enum a => Enumerable a [A] Stream [A] UnStream :: (State StreamK m a -> s -> m (Step s a)) -> s -> Stream m a [A] Step [A] Yield :: a -> s -> Step s a [A] Stop :: Step s a [A] Skip :: s -> Step s a [A] InterleaveState [A] InterleaveSecondOnly :: s2 -> InterleaveState s1 s2 [A] InterleaveSecond :: s1 -> s2 -> InterleaveState s1 s2 [A] InterleaveFirstOnly :: s1 -> InterleaveState s1 s2 [A] InterleaveFirst :: s1 -> s2 -> InterleaveState s1 s2 [A] FoldManyPost [A] FoldManyPostYield :: b -> FoldManyPost s fs b a -> FoldManyPost s fs b a [A] FoldManyPostStart :: s -> FoldManyPost s fs b a [A] FoldManyPostLoop :: s -> fs -> FoldManyPost s fs b a [A] FoldManyPostDone :: FoldManyPost s fs b a [A] FoldMany [A] FoldManyYield :: b -> FoldMany s fs b a -> FoldMany s fs b a [A] FoldManyStart :: s -> FoldMany s fs b a [A] FoldManyLoop :: s -> fs -> FoldMany s fs b a [A] FoldManyFirst :: fs -> s -> FoldMany s fs b a [A] FoldManyDone :: FoldMany s fs b a [A] CrossStream [A] ConcatUnfoldInterleaveState [A] ConcatUnfoldInterleaveOuter :: o -> [i] -> ConcatUnfoldInterleaveState o i [A] ConcatUnfoldInterleaveInnerR :: [i] -> [i] -> ConcatUnfoldInterleaveState o i [A] ConcatUnfoldInterleaveInnerL :: [i] -> [i] -> ConcatUnfoldInterleaveState o i [A] ConcatUnfoldInterleaveInner :: o -> [i] -> ConcatUnfoldInterleaveState o i [A] ConcatMapUState [A] ConcatMapUOuter :: o -> ConcatMapUState o i [A] ConcatMapUInner :: o -> i -> ConcatMapUState o i [A] AppendState [A] AppendSecond :: s2 -> AppendState s1 s2 [A] AppendFirst :: s1 -> AppendState s1 s2 [A] pattern Stream :: (State StreamK m a -> s -> m (Step s a)) -> s -> Stream m a [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Stream m b -> Stream m c [A] zipWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c [A] wordsBy :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [A] with :: Monad m => (Stream m a -> Stream m (s, a)) -> (((s, a) -> b) -> Stream m (s, a) -> Stream m (s, a)) -> ((s, a) -> b) -> Stream m a -> Stream m a [A] usingStateT :: Monad m => m s -> (Stream (StateT s m) a -> Stream (StateT s m) a) -> Stream m a -> Stream m a [A] usingReaderT :: Monad m => m r -> (Stream (ReaderT r m) a -> Stream (ReaderT r m) a) -> Stream m a -> Stream m a [A] uniqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a [A] uniq :: (Eq a, Monad m) => Stream m a -> Stream m a [A] unionWithStreamGenericBy :: MonadIO m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a [A] unionWithStreamAscBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a [A] unfoldrM :: Monad m => (s -> m (Maybe (a, s))) -> s -> Stream m a [A] unfoldr :: Monad m => (s -> Maybe (a, s)) -> s -> Stream m a [A] unfoldRoundRobin :: Monad m => Unfold m a b -> Stream m a -> Stream m b [A] unfoldMany :: Monad m => Unfold m a b -> Stream m a -> Stream m b [A] unfoldIterateDfs :: Monad m => Unfold m a a -> Stream m a -> Stream m a [A] unfoldIterateBfsRev :: Monad m => Unfold m a a -> Stream m a -> Stream m a [A] unfoldIterateBfs :: Monad m => Unfold m a a -> Stream m a -> Stream m a [A] unfoldInterleave :: Monad m => Unfold m a b -> Stream m a -> Stream m b [A] unfold :: Applicative m => Unfold m a b -> a -> Stream m b [A] uncons :: Monad m => Stream m a -> m (Maybe (a, Stream m a)) [A] unCross :: CrossStream m a -> Stream m a [A] transform :: Monad m => Pipe m a b -> Stream m a -> Stream m b [A] trace_ :: Monad m => m b -> Stream m a -> Stream m a [A] trace :: Monad m => (a -> m b) -> Stream m a -> Stream m a [A] toStreamK :: Monad m => Stream m a -> StreamK m a [A] toListRev :: Monad m => Stream m a -> m [a] [A] toList :: Monad m => Stream m a -> m [a] [A] timestamped :: MonadIO m => Stream m a -> Stream m (AbsTime, a) [A] timestampWith :: MonadIO m => Double -> Stream m a -> Stream m (AbsTime, a) [A] timesWith :: MonadIO m => Double -> Stream m (AbsTime, RelTime64) [A] times :: MonadIO m => Stream m (AbsTime, RelTime64) [A] timeout :: AbsTime -> t m () [A] timeIndexed :: MonadIO m => Stream m a -> Stream m (RelTime64, a) [A] timeIndexWith :: MonadIO m => Double -> Stream m a -> Stream m (RelTime64, a) [A] the :: (Eq a, Monad m) => Stream m a -> m (Maybe a) [A] tapOffsetEvery :: Monad m => Int -> Int -> Fold m a b -> Stream m a -> Stream m a [A] tap :: Monad m => Fold m a b -> Stream m a -> Stream m a [A] takeWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a [A] takeWhileLast :: (a -> Bool) -> Stream m a -> Stream m a [A] takeWhileAround :: (a -> Bool) -> Stream m a -> Stream m a [A] takeWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a [A] takeEndByM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a [A] takeEndBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m a [A] take :: Applicative m => Int -> Stream m a -> Stream m a [A] tail :: Monad m => Stream m a -> m (Maybe (Stream m a)) [A] stripSuffixUnbox :: (MonadIO m, Eq a, Unbox a) => Stream m a -> Stream m a -> m (Maybe (Stream m a)) [A] stripSuffix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a)) [A] stripPrefix :: (Monad m, Eq a) => Stream m a -> Stream m a -> m (Maybe (Stream m a)) [A] strideFromThen :: Monad m => Int -> Int -> Stream m a -> Stream m a [A] splitOnSuffixSeqAny :: [Array a] -> Fold m a b -> Stream m a -> Stream m b [A] 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 [A] splitOnSeq :: forall m a b. (MonadIO m, Storable a, Unbox a, Enum a, Eq a) => Array a -> Fold m a b -> Stream m a -> Stream m b [A] splitOnPrefix :: (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [A] splitOnAny :: [Array a] -> Fold m a b -> Stream m a -> Stream m b [A] splitOn :: Monad m => (a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [A] splitInnerBySuffix :: (Monad m, Eq (f a), Monoid (f a)) => (f a -> m (f a, Maybe (f a))) -> (f a -> f a -> m (f a)) -> Stream m (f a) -> Stream m (f a) [A] splitInnerBy :: Monad m => (f a -> m (f a, Maybe (f a))) -> (f a -> f a -> m (f a)) -> Stream m (f a) -> Stream m (f a) [A] slicesBy :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int) [A] sliceOnSuffix :: Monad m => (a -> Bool) -> Stream m a -> Stream m (Int, Int) [A] sequence :: Monad m => Stream m (m a) -> Stream m a [A] scanlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> Stream m b [A] scanlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> Stream m b [A] scanlMAfter' :: Monad m => (b -> a -> m b) -> m b -> (b -> m b) -> Stream m a -> Stream m b [A] scanlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b [A] scanlM :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b [A] scanl1M' :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a [A] scanl1M :: Monad m => (a -> a -> m a) -> Stream m a -> Stream m a [A] scanl1' :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a [A] scanl1 :: Monad m => (a -> a -> a) -> Stream m a -> Stream m a [A] scanl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b [A] scanl :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b [A] scanMaybe :: Monad m => Fold m a (Maybe b) -> Stream m a -> Stream m b [A] scanMany :: Monad m => Fold m a b -> Stream m a -> Stream m b [A] scan :: Monad m => Fold m a b -> Stream m a -> Stream m b [A] runStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m (s, a) [A] runReaderT :: Monad m => m s -> Stream (ReaderT s m) a -> Stream m a [A] runInnerWithState :: Monad m => (forall b. s -> t m b -> m (b, s)) -> m s -> Stream (t m) a -> Stream m (s, a) [A] runInnerWith :: Monad m => (forall b. t m b -> m b) -> Stream (t m) a -> Stream m a [A] roundRobin :: Monad m => Stream m a -> Stream m a -> Stream m a [A] rollingMapM :: Monad m => (Maybe a -> a -> m b) -> Stream m a -> Stream m b [A] rollingMap2 :: Monad m => (a -> a -> b) -> Stream m a -> Stream m b [A] rollingMap :: Monad m => (Maybe a -> a -> b) -> Stream m a -> Stream m b [A] reverseUnbox :: (MonadIO m, Unbox a) => Stream m a -> Stream m a [A] reverse :: Monad m => Stream m a -> Stream m a [A] replicateM :: Monad m => Int -> m a -> Stream m a [A] replicate :: Monad m => Int -> a -> Stream m a [A] repeated :: Stream m a -> Stream m a [A] repeatM :: Monad m => m a -> Stream m a [A] repeat :: Monad m => a -> Stream m a [A] relTimesWith :: MonadIO m => Double -> Stream m RelTime64 [A] relTimes :: MonadIO m => Stream m RelTime64 [A] refoldMany :: Monad m => Refold m x a b -> m x -> Stream m a -> Stream m b [A] refoldIterateM :: Monad m => Refold m b a b -> m b -> Stream m a -> Stream m b [A] reduceIterateBfs :: Monad m => (a -> a -> m a) -> Stream m a -> m (Maybe a) [A] reassembleBy :: Fold m a b -> (a -> a -> Int) -> Stream m a -> Stream m b [A] prune :: (a -> Bool) -> Stream m a -> Stream m a [A] prescanlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b [A] prescanl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> Stream m b [A] postscanlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> Stream m b [A] postscanlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> Stream m b [A] postscanlMAfter' :: Monad m => (b -> a -> m b) -> m b -> (b -> m b) -> Stream m a -> Stream m b [A] postscanlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b [A] postscanlM :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> Stream m b [A] postscanl' :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a [A] postscanl :: Monad m => (a -> b -> a) -> a -> Stream m b -> Stream m a [A] postscan :: Monad m => Fold m a b -> Stream m a -> Stream m b [A] parseSequence :: Stream m (Parser a m b) -> Stream m a -> Stream m b [A] parseManyTill :: Parser a m b -> Parser a m x -> Stream m a -> Stream m b [A] parseManyD :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b) [A] parseMany :: Monad m => Parser a m b -> Stream m a -> Stream m (Either ParseError b) [A] parseIterateD :: Monad m => (b -> Parser a m b) -> b -> Stream m a -> Stream m (Either ParseError b) [A] parseIterate :: Monad m => (b -> Parser a m b) -> b -> Stream m a -> Stream m (Either ParseError b) [A] parseD :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b) [A] parseBreakD :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a) [A] parseBreak :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b, Stream m a) [A] parse :: Monad m => Parser a m b -> Stream m a -> m (Either ParseError b) [A] onException :: MonadCatch m => m b -> Stream m a -> Stream m a [A] null :: Monad m => Stream m a -> m Bool [A] nub :: (Monad m, Ord a) => Stream m a -> Stream m a [A] notElem :: (Monad m, Eq a) => a -> Stream m a -> m Bool [A] nilM :: Applicative m => m b -> Stream m a [A] nil :: Applicative m => Stream m a [A] morphInner :: Monad n => (forall x. m x -> n x) -> Stream m a -> Stream n a [A] mkCross :: Stream m a -> CrossStream m a [A] minimumBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> m (Maybe a) [A] minimum :: (Monad m, Ord a) => Stream m a -> m (Maybe a) [A] mergeMinBy :: (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a [A] mergeFstBy :: (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a [A] mergeByM :: Monad m => (a -> a -> m Ordering) -> Stream m a -> Stream m a -> Stream m a [A] mergeBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a [A] maximumBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> m (Maybe a) [A] maximum :: (Monad m, Ord a) => Stream m a -> m (Maybe a) [A] mapMaybeM :: Monad m => (a -> m (Maybe b)) -> Stream m a -> Stream m b [A] mapMaybe :: Monad m => (a -> Maybe b) -> Stream m a -> Stream m b [A] mapM_ :: Monad m => (a -> m b) -> Stream m a -> m () [A] mapM :: Monad m => (a -> m b) -> Stream m a -> Stream m b [A] map :: Monad m => (a -> b) -> Stream m a -> Stream m b [A] lookup :: (Monad m, Eq a) => a -> Stream m (a, b) -> m (Maybe b) [A] liftInnerWith :: Monad (t m) => (forall b. m b -> t m b) -> Stream m a -> Stream (t m) a [A] liftInner :: (Monad m, MonadTrans t, Monad (t m)) => Stream m a -> Stream (t m) a [A] last :: Monad m => Stream m a -> m (Maybe a) [A] joinOuterGeneric :: MonadIO m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b) [A] joinOuterAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (Maybe a, Maybe b) [A] joinOuter :: (Ord k, MonadIO m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, Maybe a, Maybe b) [A] joinLeftGeneric :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, Maybe b) [A] joinLeftAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, Maybe b) [A] joinLeft :: (Ord k, Monad m) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, Maybe b) [A] joinInnerGeneric :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> Stream m (a, b) [A] joinInnerAscBy :: (a -> b -> Ordering) -> Stream m a -> Stream m b -> Stream m (a, b) [A] joinInner :: (Monad m, Ord k) => Stream m (k, a) -> Stream m (k, b) -> Stream m (k, a, b) [A] iterateM :: Monad m => (a -> m a) -> m a -> Stream m a [A] iterate :: Monad m => (a -> a) -> a -> Stream m a [A] isSuffixOfUnbox :: (MonadIO m, Eq a, Unbox a) => Stream m a -> Stream m a -> m Bool [A] isSuffixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool [A] isSubsequenceOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool [A] isPrefixOf :: (Monad m, Eq a) => Stream m a -> Stream m a -> m Bool [A] isInfixOf :: (MonadIO m, Eq a, Enum a, Storable a, Unbox a) => Stream m a -> Stream m a -> m Bool [A] intersperseM_ :: Monad m => m b -> Stream m a -> Stream m a [A] intersperseMWith :: Int -> m a -> Stream m a -> Stream m a [A] intersperseMSuffix_ :: Monad m => m b -> Stream m a -> Stream m a [A] intersperseMSuffixWith :: forall m a. Monad m => Int -> m a -> Stream m a -> Stream m a [A] intersperseMSuffix :: forall m a. Monad m => m a -> Stream m a -> Stream m a [A] intersperseMPrefix_ :: Monad m => m b -> Stream m a -> Stream m a [A] intersperseM :: Monad m => m a -> Stream m a -> Stream m a [A] intersperse :: Monad m => a -> Stream m a -> Stream m a [A] intersectBySorted :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a [A] interposeSuffixM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c [A] interposeSuffix :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c [A] interposeM :: Monad m => m c -> Unfold m b c -> Stream m b -> Stream m c [A] interpose :: Monad m => c -> Unfold m b c -> Stream m b -> Stream m c [A] interleaveMin :: Monad m => Stream m a -> Stream m a -> Stream m a [A] interleaveFstSuffix :: Monad m => Stream m a -> Stream m a -> Stream m a [A] interleaveFst :: Monad m => Stream m a -> Stream m a -> Stream m a [A] interleave :: Monad m => Stream m a -> Stream m a -> Stream m a [A] intercalateSuffix :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c [A] intercalate :: Monad m => Unfold m b c -> b -> Stream m b -> Stream m c [A] insertBy :: Monad m => (a -> a -> Ordering) -> a -> Stream m a -> Stream m a [A] indexedR :: Monad m => Int -> Stream m a -> Stream m (Int, a) [A] indexed :: Monad m => Stream m a -> Stream m (Int, a) [A] headElse :: Monad m => a -> Stream m a -> m a [A] head :: Monad m => Stream m a -> m (Maybe a) [A] handle :: (MonadCatch m, Exception e) => (e -> m (Stream m a)) -> Stream m a -> Stream m a [A] groupsWhile :: Monad m => (a -> a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [A] groupsRollingBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Stream m a -> Stream m b [A] groupsOf :: Monad m => Int -> Fold m a b -> Stream m a -> Stream m b [A] gintercalateSuffix :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c [A] gintercalate :: Monad m => Unfold m a c -> Stream m a -> Unfold m b c -> Stream m b -> Stream m c [A] ghandle :: (MonadCatch m, Exception e) => (e -> Stream m a -> m (Stream m a)) -> Stream m a -> Stream m a [A] generateM :: Monad m => Int -> (Int -> m a) -> Stream m a [A] generate :: Monad m => Int -> (Int -> a) -> Stream m a [A] generalizeInner :: Monad m => Stream Identity a -> Stream m a [A] gbracket_ :: Monad m => m c -> (c -> m d) -> (c -> e -> Stream m b -> m (Stream m b)) -> (forall s. m s -> m (Either e s)) -> (c -> Stream m b) -> Stream m b [A] gbracket :: MonadIO m => IO c -> (c -> IO d1) -> (c -> e -> Stream m b -> IO (Stream m b)) -> (c -> IO d2) -> (forall s. m s -> m (Either e s)) -> (c -> Stream m b) -> Stream m b [A] fromStreamK :: Applicative m => StreamK m a -> Stream m a [A] fromPure :: Applicative m => a -> Stream m a [A] fromPtrN :: (Monad m, Storable a) => Int -> Ptr a -> Stream m a [A] fromPtr :: forall m a. (Monad m, Storable a) => Ptr a -> Stream m a [A] fromListM :: Monad m => [m a] -> Stream m a [A] fromList :: Applicative m => [a] -> Stream m a [A] fromIndicesM :: Monad m => (Int -> m a) -> Stream m a [A] fromIndices :: Monad m => (Int -> a) -> Stream m a [A] fromFoldableM :: (Monad m, Foldable f) => f (m a) -> Stream m a [A] fromFoldable :: (Monad m, Foldable f) => f a -> Stream m a [A] fromEffect :: Applicative m => m a -> Stream m a [A] fromByteStr# :: Monad m => Addr# -> Stream m Word8 [A] foldrT :: (Monad m, Monad (t m), MonadTrans t) => (a -> t m b -> t m b) -> t m b -> Stream m a -> t m b [A] foldrS :: Monad m => (a -> Stream m b -> Stream m b) -> Stream m b -> Stream m a -> Stream m b [A] foldrMx :: Monad m => (a -> m x -> m x) -> m x -> (m x -> m b) -> Stream m a -> m b [A] foldrM :: Monad m => (a -> m b -> m b) -> m b -> Stream m a -> m b [A] foldr1 :: Monad m => (a -> a -> a) -> Stream m a -> m (Maybe a) [A] foldr :: Monad m => (a -> b -> b) -> b -> Stream m a -> m b [A] foldlx' :: Monad m => (x -> a -> x) -> x -> (x -> b) -> Stream m a -> m b [A] foldlT :: (Monad m, Monad (s m), MonadTrans s) => (s m b -> a -> s m b) -> s m b -> Stream m a -> s m b [A] foldlS :: Monad m => (Stream m b -> a -> Stream m b) -> Stream m b -> Stream m a -> Stream m b [A] foldlMx' :: Monad m => (x -> a -> m x) -> m x -> (x -> m b) -> Stream m a -> m b [A] foldlM' :: Monad m => (b -> a -> m b) -> m b -> Stream m a -> m b [A] foldl' :: Monad m => (b -> a -> b) -> b -> Stream m a -> m b [A] foldSequence :: Stream m (Fold m a b) -> Stream m a -> Stream m b [A] foldManyPost :: Monad m => Fold m a b -> Stream m a -> Stream m b [A] foldMany :: Monad m => Fold m a b -> Stream m a -> Stream m b [A] foldIterateM :: Monad m => (b -> m (Fold m a b)) -> m b -> Stream m a -> Stream m b [A] foldIterateBfs :: Fold m a (Either a a) -> Stream m a -> m (Maybe a) [A] foldEither :: Monad m => Fold m a b -> Stream m a -> m (Either (Fold m a b) (b, Stream m a)) [A] foldBreak :: Monad m => Fold m a b -> Stream m a -> m (b, Stream m a) [A] foldAddLazy :: Monad m => Fold m a b -> Stream m a -> Fold m a b [A] foldAdd :: Monad m => Fold m a b -> Stream m a -> m (Fold m a b) [A] fold :: Monad m => Fold m a b -> Stream m a -> m b [A] findM :: Monad m => (a -> m Bool) -> Stream m a -> m (Maybe a) [A] findIndices :: Monad m => (a -> Bool) -> Stream m a -> Stream m Int [A] find :: Monad m => (a -> Bool) -> Stream m a -> m (Maybe a) [A] finallyUnsafe :: MonadCatch m => m b -> Stream m a -> Stream m a [A] finallyIO :: (MonadIO m, MonadCatch m) => IO b -> Stream m a -> Stream m a [A] filterM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a [A] filterInStreamGenericBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a [A] filterInStreamAscBy :: Monad m => (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a [A] filter :: Monad m => (a -> Bool) -> Stream m a -> Stream m a [A] evalStateT :: Monad m => m s -> Stream (StateT s m) a -> Stream m a [A] eqBy :: Monad m => (a -> b -> Bool) -> Stream m a -> Stream m b -> m Bool [A] enumerateTo :: (Monad m, Bounded a, Enumerable a) => a -> Stream m a [A] enumerateFromToSmall :: (Monad m, Enum a) => a -> a -> Stream m a [A] enumerateFromToIntegral :: (Monad m, Integral a) => a -> a -> Stream m a [A] enumerateFromToFractional :: (Monad m, Fractional a, Ord a) => a -> a -> Stream m a [A] enumerateFromTo :: (Enumerable a, Monad m) => a -> a -> Stream m a [A] enumerateFromThenToSmall :: (Monad m, Enum a) => a -> a -> a -> Stream m a [A] enumerateFromThenToIntegral :: (Monad m, Integral a) => a -> a -> a -> Stream m a [A] enumerateFromThenToFractional :: (Monad m, Fractional a, Ord a) => a -> a -> a -> Stream m a [A] enumerateFromThenTo :: (Enumerable a, Monad m) => a -> a -> a -> Stream m a [A] enumerateFromThenSmallBounded :: (Monad m, Enumerable a, Bounded a) => a -> a -> Stream m a [A] enumerateFromThenNum :: (Monad m, Num a) => a -> a -> Stream m a [A] enumerateFromThenIntegral :: (Monad m, Integral a, Bounded a) => a -> a -> Stream m a [A] enumerateFromThenFractional :: (Monad m, Fractional a) => a -> a -> Stream m a [A] enumerateFromThen :: (Enumerable a, Monad m) => a -> a -> Stream m a [A] enumerateFromStepNum :: (Monad m, Num a) => a -> a -> Stream m a [A] enumerateFromStepIntegral :: (Integral a, Monad m) => a -> a -> Stream m a [A] enumerateFromNum :: (Monad m, Num a) => a -> Stream m a [A] enumerateFromIntegral :: (Monad m, Integral a, Bounded a) => a -> Stream m a [A] enumerateFromFractional :: (Monad m, Fractional a) => a -> Stream m a [A] enumerateFromBounded :: (Monad m, Enumerable a, Bounded a) => a -> Stream m a [A] enumerateFrom :: (Enumerable a, Monad m) => a -> Stream m a [A] enumerate :: (Monad m, Bounded a, Enumerable a) => Stream m a [A] elemIndices :: (Monad m, Eq a) => a -> Stream m a -> Stream m Int [A] elem :: (Monad m, Eq a) => a -> Stream m a -> m Bool [A] durations :: Double -> t m RelTime64 [A] dropWhileM :: Monad m => (a -> m Bool) -> Stream m a -> Stream m a [A] dropWhileLast :: (a -> Bool) -> Stream m a -> Stream m a [A] dropWhileAround :: (a -> Bool) -> Stream m a -> Stream m a [A] dropWhile :: Monad m => (a -> Bool) -> Stream m a -> Stream m a [A] dropSuffix :: Stream m a -> Stream m a -> Stream m a [A] dropPrefix :: Stream m a -> Stream m a -> Stream m a [A] dropLast :: Int -> Stream m a -> Stream m a [A] dropInfix :: Stream m a -> Stream m a -> Stream m a [A] drop :: Monad m => Int -> Stream m a -> Stream m a [A] drain :: Monad m => Stream m a -> m () [A] deleteInStreamGenericBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Stream m a -> Stream m a [A] deleteInStreamAscBy :: (a -> a -> Ordering) -> Stream m a -> Stream m a -> Stream m a [A] deleteBy :: Monad m => (a -> a -> Bool) -> a -> Stream m a -> Stream m a [A] delayPre :: MonadIO m => Double -> Stream m a -> Stream m a [A] delayPost :: MonadIO m => Double -> Stream m a -> Stream m a [A] delay :: MonadIO m => Double -> Stream m a -> Stream m a [A] crossWith :: Monad m => (a -> b -> c) -> Stream m a -> Stream m b -> Stream m c [A] crossApplySnd :: Functor f => Stream f a -> Stream f b -> Stream f b [A] crossApplyFst :: Functor f => Stream f a -> Stream f b -> Stream f a [A] crossApply :: Functor f => Stream f (a -> b) -> Stream f a -> Stream f b [A] cross :: Monad m => Stream m a -> Stream m b -> Stream m (a, b) [A] consM :: Applicative m => m a -> Stream m a -> Stream m a [A] cons :: Applicative m => a -> Stream m a -> Stream m a [A] concatMapM :: Monad m => (a -> m (Stream m b)) -> Stream m a -> Stream m b [A] concatMap :: Monad m => (a -> Stream m b) -> Stream m a -> Stream m b [A] concatIterateScan :: Monad m => (b -> a -> m b) -> (b -> m (Maybe (b, Stream m a))) -> b -> Stream m a [A] concatIterateDfs :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a [A] concatIterateBfsRev :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a [A] concatIterateBfs :: Monad m => (a -> Maybe (Stream m a)) -> Stream m a -> Stream m a [A] concatEffect :: Monad m => m (Stream m a) -> Stream m a [A] concat :: Monad m => Stream m (Stream m a) -> Stream m a [A] cmpBy :: Monad m => (a -> b -> Ordering) -> Stream m a -> Stream m b -> m Ordering [A] catRights :: Monad m => Stream m (Either a b) -> Stream m b [A] catMaybes :: Monad m => Stream m (Maybe a) -> Stream m a [A] catLefts :: Monad m => Stream m (Either a b) -> Stream m a [A] catEithers :: Monad m => Stream m (Either a a) -> Stream m a [A] bracketUnsafe :: MonadCatch m => m b -> (b -> m c) -> (b -> Stream m a) -> Stream m a [A] bracketIO3 :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> IO d) -> (b -> IO e) -> (b -> Stream m a) -> Stream m a [A] bracketIO :: (MonadIO m, MonadCatch m) => IO b -> (b -> IO c) -> (b -> Stream m a) -> Stream m a [A] before :: Monad m => m b -> Stream m a -> Stream m a [A] append :: Monad m => Stream m a -> Stream m a -> Stream m a [A] any :: Monad m => (a -> Bool) -> Stream m a -> m Bool [A] all :: Monad m => (a -> Bool) -> Stream m a -> m Bool [A] afterUnsafe :: Monad m => m b -> Stream m a -> Stream m a [A] afterIO :: MonadIO m => IO b -> Stream m a -> Stream m a [A] absTimesWith :: MonadIO m => Double -> Stream m AbsTime [A] absTimes :: MonadIO m => Stream m AbsTime [A] (!!) :: Monad m => Stream m a -> Int -> m (Maybe a) [R] Streamly.Internal.Data.Ring.Unboxed [A] Streamly.Internal.Data.Ring.Generic [A] Ring [A] [ringMax] :: Ring a -> !Int [A] [ringHead] :: Ring a -> !Int [A] [ringArr] :: Ring a -> MutArray a [A] Ring :: MutArray a -> !Int -> !Int -> Ring a [A] writeLastN :: MonadIO m => Int -> Fold m a (Ring a) [A] unsafeInsertRingWith :: Ring a -> a -> IO Int [A] toStreamWith :: Int -> Ring a -> Stream m a [A] toMutArray :: MonadIO m => Int -> Int -> Ring a -> m (MutArray a) [A] seek :: MonadIO m => Int -> Ring a -> m (Ring a) [A] createRing :: MonadIO m => Int -> m (Ring a) [A] copyToMutArray :: MonadIO m => Int -> Int -> Ring a -> m (MutArray a) [C] Streamly.Internal.Data.Ring [C] Ring [A] [ringStart] :: Ring a -> {-# UNPACK #-} !ForeignPtr a [R] [ringMax] :: Ring a -> !Int [R] [ringHead] :: Ring a -> !Int [A] [ringBound] :: Ring a -> {-# UNPACK #-} !Ptr a [R] [ringArr] :: Ring a -> MutArray a [C] Ring [O] Ring :: MutArray a -> !Int -> !Int -> Ring a [N] Ring :: {-# UNPACK #-} !ForeignPtr a -> {-# UNPACK #-} !Ptr a -> Ring a [A] GHC.Show.Show [A] instance (GHC.Show.Show a, GHC.Show.Show b, GHC.Show.Show c, GHC.Show.Show d) => GHC.Show.Show (Streamly.Internal.Data.Ring.Tuple4' a b c d) [A] writeN :: Int -> Fold m a (Ring a) [R] writeLastN :: MonadIO m => Int -> Fold m a (Ring a) [R] unsafeInsertRingWith :: Ring a -> a -> IO Int [A] unsafeInsert :: Storable a => Ring a -> Ptr a -> a -> IO (Ptr a) [A] unsafeFoldRingNM :: forall m a b. (MonadIO m, Storable a) => Int -> Ptr a -> (b -> a -> m b) -> b -> Ring a -> m b [A] unsafeFoldRingM :: forall m a b. (MonadIO m, Storable a) => Ptr a -> (b -> a -> m b) -> b -> Ring a -> m b [A] unsafeFoldRingFullM :: forall m a b. (MonadIO m, Storable a) => Ptr a -> (b -> a -> m b) -> b -> Ring a -> m b [A] unsafeFoldRing :: forall a b. Storable a => Ptr a -> (b -> a -> b) -> b -> Ring a -> b [A] unsafeEqArrayN :: Ring a -> Ptr a -> Array a -> Int -> Bool [A] unsafeEqArray :: Ring a -> Ptr a -> Array a -> Bool [R] toStreamWith :: Int -> Ring a -> Stream m a [R] toMutArray :: MonadIO m => Int -> Int -> Ring a -> m (MutArray a) [A] startOf :: Ring a -> Ptr a [A] slidingWindowWith :: forall m a b. (MonadIO m, Storable a, Unbox a) => Int -> Fold m ((a, Maybe a), m (MutArray a)) b -> Fold m a b [A] slidingWindow :: forall m a b. (MonadIO m, Storable a, Unbox a) => Int -> Fold m (a, Maybe a) b -> Fold m a b [A] slide :: Ring a -> a -> m (Ring a) [R] seek :: MonadIO m => Int -> Ring a -> m (Ring a) [A] ringsOf :: Int -> Stream m a -> Stream m (MutArray a) [A] readRev :: Unfold m (MutArray a) a [A] read :: forall m a. (MonadIO m, Storable a) => Unfold m (Ring a, Ptr a, Int) a [A] putIndex :: Ring a -> Int -> a -> m () [A] newRing :: Int -> m (Ring a) [A] new :: forall a. Storable a => Int -> IO (Ring a, Ptr a) [A] moveBy :: forall a. Storable a => Int -> Ring a -> Ptr a -> Ptr a [A] modifyIndex :: Ring a -> Int -> (a -> (a, b)) -> m b [A] length :: Ring a -> Int [A] getIndexUnsafe :: Ring a -> Int -> m a [A] getIndexRev :: Ring a -> Int -> m a [A] getIndex :: Ring a -> Int -> m a [A] fromArray :: MutArray a -> Ring a [R] createRing :: MonadIO m => Int -> m (Ring a) [A] castUnsafe :: Ring a -> Ring b [A] cast :: forall a b. Storable b => Ring a -> Maybe (Ring b) [A] bytesFree :: Ring a -> Int [A] byteLength :: Ring a -> Int [A] byteCapacity :: Ring a -> Int [A] asBytes :: Ring a -> Ring Word8 [A] advance :: forall a. Storable a => Ring a -> Ptr a -> Ptr a [R] Streamly.Internal.Data.Producer.Type [R] Streamly.Internal.Data.Producer.Source [C] Streamly.Internal.Data.Producer [A] Source [A] unread :: [b] -> Source a b -> Source a b [A] translate :: Functor m => (a -> c) -> (c -> a) -> Producer m c b -> Producer m a b [A] source :: Maybe a -> Source a b [A] producer :: Monad m => Producer m a b -> Producer m (Source a b) b [A] parseManyD :: Monad m => Parser a m b -> Producer m (Source x a) a -> Producer m (Source x a) (Either ParseError b) [A] parseMany :: Monad m => Parser a m b -> Producer m (Source x a) a -> Producer m (Source x a) (Either ParseError b) [A] parse :: Monad m => Parser a m b -> Producer m (Source s a) a -> Source s a -> m (Either ParseError b, Source s a) [A] lmap :: (a -> a) -> Producer m a b -> Producer m a b [A] isEmpty :: Source a b -> Bool [R] Streamly.Internal.Data.Pipe.Type [C] Streamly.Internal.Data.Pipe [A] Step [A] Yield :: a -> s -> Step s a [A] Continue :: s -> Step s a [A] PipeState [A] Produce :: s2 -> PipeState s1 s2 [A] Consume :: s1 -> PipeState s1 s2 [C] Pipe [A] Pipe :: (s1 -> a -> m (Step (PipeState s1 s2) b)) -> (s2 -> m (Step (PipeState s1 s2) b)) -> s1 -> Pipe m a b [A] Streamly.Internal.Data.ParserK [A] Step [A] Partial :: !Int -> (Input a -> m (Step a m r)) -> Step a m r [A] Error :: !Int -> String -> Step a m r [A] Done :: !Int -> r -> Step a m r [A] Continue :: !Int -> (Input a -> m (Step a m r)) -> Step a m r [A] ParseResult [A] Success :: !Int -> !b -> ParseResult b [A] Failure :: !Int -> !String -> ParseResult b [A] Input [A] None :: Input a [A] Chunk :: a -> Input a [A] ParserK [A] [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) [A] 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 [A] fromPure :: b -> ParserK a m b [A] fromEffect :: Monad m => m b -> ParserK a m b [A] die :: String -> ParserK a m b [A] adaptCG :: Monad m => Parser a m b -> ParserK (Array a) m b [A] adaptC :: (Monad m, Unbox a) => Parser a m b -> ParserK (Array a) m b [A] adapt :: Monad m => Parser a m b -> ParserK a m b [R] Streamly.Internal.Data.Parser.ParserK.Type [R] Streamly.Internal.Data.Parser.ParserD.Type [R] Streamly.Internal.Data.Parser.ParserD.Tee [R] Streamly.Internal.Data.Parser.ParserD [C] Streamly.Internal.Data.Parser [A] Step [A] Partial :: !Int -> !s -> Step s b [A] Error :: !String -> Step s b [A] Done :: !Int -> !b -> Step s b [A] Continue :: !Int -> !s -> Step s b [A] Parser [A] Parser :: (s -> a -> m (Step s b)) -> m (Initial s b) -> (s -> m (Step s b)) -> Parser a m b [A] Initial [A] IPartial :: !s -> Initial s b [A] IError :: !String -> Initial s b [A] IDone :: !b -> Initial s b [A] GHC.Show.Show [A] instance (GHC.Show.Show a, GHC.Show.Show b) => GHC.Show.Show (Streamly.Internal.Data.Parser.Tuple'Fused a b) [A] ParseError [A] ParseError :: String -> ParseError [A] zipWithM :: Monad m => (a -> b -> m c) -> Stream m a -> Fold m c x -> Parser b m x [A] zip :: Monad m => Stream m a -> Fold m (a, b) x -> Parser b m x [A] wordWithQuotes :: (Monad m, Eq a) => Bool -> (a -> a -> Maybe a) -> a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b [A] wordProcessQuotes :: (Monad m, Eq a) => a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b [A] wordKeepQuotes :: (Monad m, Eq a) => a -> (a -> Maybe a) -> (a -> Bool) -> Fold m a b -> Parser a m b [A] wordFramedBy :: Monad m => (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> Fold m a b -> Parser a m b [A] wordBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b [A] toFold :: Monad m => Parser a m b -> Fold m a b [A] takeWhileP :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b [A] takeWhile1 :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b [A] takeWhile :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b [A] takeStartBy_ :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b [A] takeStartBy :: Monad m => (a -> Bool) -> Fold m a b -> Parser a m b [A] takeP :: Monad m => Int -> Parser a m b -> Parser a m b [A] takeGE :: Monad m => Int -> Fold m a b -> Parser a m b [A] takeFramedBy_ :: Monad m => (a -> Bool) -> (a -> Bool) -> Fold m a b -> Parser a m b [A] takeFramedByGeneric :: Monad m => Maybe (a -> Bool) -> Maybe (a -> Bool) -> Maybe (a -> Bool) -> Fold m a b -> Parser a m b [A] takeFramedByEsc_ :: Monad m => (a -> Bool) -> (a -> Bool) -> (a -> Bool) -> Fold m a b -> Parser a m b [A] takeEndBy_ :: (a -> Bool) -> Parser a m b -> Parser a m b [A] takeEndByEsc :: Monad m => (a -> Bool) -> (a -> Bool) -> Parser a m b -> Parser a m b [A] takeEndBy :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b [A] takeEitherSepBy :: (a -> Bool) -> Fold m (Either a b) c -> Parser a m c [A] takeEQ :: Monad m => Int -> Fold m a b -> Parser a m b [A] takeBetween :: Monad m => Int -> Int -> Fold m a b -> Parser a m b [A] subsequenceBy :: (a -> a -> Bool) -> Stream m a -> Parser a m () [A] streamEqBy :: Monad m => (a -> a -> Bool) -> Stream m a -> Parser a m () [A] split_ :: Monad m => Parser x m a -> Parser x m b -> Parser x m b [A] splitWith :: Monad m => (a -> b -> c) -> Parser x m a -> Parser x m b -> Parser x m c [A] splitSome :: Monad m => Parser a m b -> Fold m b c -> Parser a m c [A] splitManyPost :: Monad m => Parser a m b -> Fold m b c -> Parser a m c [A] splitMany :: Monad m => Parser a m b -> Fold m b c -> Parser a m c [A] spanByRolling :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (b, c) [A] spanBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (b, c) [A] span :: Monad m => (a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (b, c) [A] some :: Monad m => Parser a m b -> Fold m b c -> Parser a m c [A] sequence :: Monad m => Stream m (Parser a m b) -> Fold m b c -> Parser a m c [A] sepByAll :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c [A] sepBy1 :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c [A] sepBy :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c [A] satisfy :: Monad m => (a -> Bool) -> Parser a m a [A] sampleFromthen :: Monad m => Int -> Int -> Fold m a b -> Parser a m b [A] roundRobin :: t (Parser a m b) -> Fold m b c -> Parser a m c [A] rmapM :: Monad m => (b -> m c) -> Parser a m b -> Parser a m c [A] retryMaxTotal :: Int -> Parser a m b -> Fold m b c -> Parser a m c [A] retryMaxSuccessive :: Int -> Parser a m b -> Fold m b c -> Parser a m c [A] retry :: Parser a m b -> Parser a m b [A] postscan :: Fold m a b -> Parser b m c -> Parser a m c [A] peek :: Monad m => Parser a m a [A] oneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a [A] oneNotEq :: (Monad m, Eq a) => a -> Parser a m a [A] oneEq :: (Monad m, Eq a) => a -> Parser a m a [A] one :: Monad m => Parser a m a [A] noneOf :: (Monad m, Eq a, Foldable f) => f a -> Parser a m a [A] noErrorUnsafeSplit_ :: Monad m => Parser x m a -> Parser x m b -> Parser x m b [A] noErrorUnsafeSplitWith :: Monad m => (a -> b -> c) -> Parser x m a -> Parser x m b -> Parser x m c [A] noErrorUnsafeConcatMap :: Monad m => (b -> Parser a m c) -> Parser a m b -> Parser a m c [A] maybe :: Monad m => (a -> Maybe b) -> Parser a m b [A] manyTillP :: Parser a m b -> Parser a m x -> Parser b m c -> Parser a m c [A] manyTill :: Monad m => Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c [A] manyThen :: Parser a m b -> Parser a m x -> Fold m b c -> Parser a m c [A] manyP :: Parser a m b -> Parser b m c -> Parser a m c [A] many :: Monad m => Parser a m b -> Fold m b c -> Parser a m c [A] makeIndexFilter :: (Fold m (s, a) b -> Parser a m b) -> (((s, a) -> Bool) -> Fold m (s, a) b -> Fold m (s, a) b) -> ((s, a) -> Bool) -> Fold m a b -> Parser a m b [A] lookAhead :: Monad m => Parser a m b -> Parser a m b [A] lmapM :: Monad m => (a -> m b) -> Parser b m r -> Parser a m r [A] lmap :: (a -> b) -> Parser b m r -> Parser a m r [A] listEqBy :: Monad m => (a -> a -> Bool) -> [a] -> Parser a m [a] [A] listEq :: (Monad m, Eq a) => [a] -> Parser a m [a] [A] indexed :: forall m a b. Monad m => Fold m (Int, a) b -> Parser a m b [A] groupByRollingEither :: Monad m => (a -> a -> Bool) -> Fold m a b -> Fold m a c -> Parser a m (Either b c) [A] groupByRolling :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b [A] groupBy :: Monad m => (a -> a -> Bool) -> Fold m a b -> Parser a m b [A] fromPure :: Monad m => b -> Parser a m b [A] fromFoldMaybe :: Monad m => String -> Fold m a (Maybe b) -> Parser a m b [A] fromFold :: Monad m => Fold m a b -> Parser a m b [A] fromEffect :: Monad m => m b -> Parser a m b [A] filter :: Monad m => (a -> Bool) -> Parser a m b -> Parser a m b [A] extractStep :: Monad m => (s -> m (Step s1 b)) -> Step s b -> m (Step s1 b) [A] eof :: Monad m => Parser a m () [A] either :: Monad m => (a -> Either String b) -> Parser a m b [A] dropWhile :: Monad m => (a -> Bool) -> Parser a m () [A] dieM :: Monad m => m String -> Parser a m b [A] die :: Monad m => String -> Parser a m b [A] deintercalateAll :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z [A] deintercalate1 :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z [A] deintercalate :: Monad m => Parser a m x -> Parser a m y -> Fold m (Either x y) z -> Parser a m z [A] countBetween :: Int -> Int -> Parser a m b -> Fold m b c -> Parser a m c [A] count :: Int -> Parser a m b -> Fold m b c -> Parser a m c [A] concatMap :: Monad m => (b -> Parser a m c) -> Parser a m b -> Parser a m c [A] blockWithQuotes :: (Monad m, Eq a) => (a -> Bool) -> (a -> Bool) -> a -> a -> Fold m a b -> Parser a m b [A] bimapOverrideCount :: Int -> (s -> s1) -> (b -> b1) -> Step s b -> Step s1 b1 [A] alt :: Monad m => Parser x m a -> Parser x m a -> Parser x m a [A] Streamly.Internal.Data.MutByteArray [A] class Unbox a [A] class SizeOfRep (f :: Type -> Type) [A] class Serialize a [A] TypeOfType [A] UnitType :: Name -> TypeOfType [A] TheType :: SimpleDataCon -> TypeOfType [A] MultiType :: [SimpleDataCon] -> TypeOfType [A] SimpleDataCon [A] SimpleDataCon :: Name -> [Field] -> SimpleDataCon [A] SerializeConfig [A] [cfgRecordSyntaxWithHeader] :: SerializeConfig -> Bool [A] [cfgInlineSize] :: SerializeConfig -> Maybe Inline [A] [cfgInlineSerialize] :: SerializeConfig -> Maybe Inline [A] [cfgInlineDeserialize] :: SerializeConfig -> Maybe Inline [A] [cfgConstructorTagAsString] :: SerializeConfig -> Bool [A] SerializeConfig :: Maybe Inline -> Maybe Inline -> Maybe Inline -> Bool -> Bool -> SerializeConfig [A] PinnedState [A] Unpinned :: PinnedState [A] Pinned :: PinnedState [A] MutByteArray [A] MutByteArray :: MutableByteArray# RealWorld -> MutByteArray [A] DataType [A] [dtTvs] :: DataType -> [Name] [A] [dtName] :: DataType -> Name [A] [dtCxt] :: DataType -> Cxt [A] [dtCons] :: DataType -> [DataCon] [A] DataType :: Name -> [Name] -> Cxt -> [DataCon] -> DataType [A] DataCon [A] [dcTvs] :: DataCon -> [Name] [A] [dcName] :: DataCon -> Name [A] [dcFields] :: DataCon -> [(Maybe Name, Type)] [A] [dcCxt] :: DataCon -> Cxt [A] DataCon :: Name -> [Name] -> Cxt -> [(Maybe Name, Type)] -> DataCon [A] BoundedPtr [A] BoundedPtr :: MutByteArray -> Int -> Int -> BoundedPtr [A] Streamly.Internal.Data.Serialize.Type.Serialize [A] instance Streamly.Internal.Data.Serialize.Type.Serialize Streamly.Internal.Data.MutByteArray.LiftedInteger [A] instance Streamly.Internal.Data.Serialize.Type.Serialize GHC.Num.Integer.Integer [A] instance Streamly.Internal.Data.Serialize.Type.Serialize a => Streamly.Internal.Data.Serialize.Type.Serialize (GHC.Maybe.Maybe a) [A] instance Streamly.Internal.Data.Serialize.Type.Serialize (Data.Proxy.Proxy a) [A] instance (Streamly.Internal.Data.Serialize.Type.Serialize a, Streamly.Internal.Data.Serialize.Type.Serialize b) => Streamly.Internal.Data.Serialize.Type.Serialize (Data.Either.Either a b) [A] Peeker [A] Peeker :: Builder BoundedPtr IO a -> Peeker a [A] type Field = (Maybe Name, Type) [A] xorCmp :: [Word8] -> Name -> Name -> Q Exp [A] wListToString :: [Word8] -> String [A] w8_int :: Word8 -> Int [A] w32_int :: Word32 -> Int [A] unpin :: MutByteArray -> IO MutByteArray [A] typeOfType :: Type -> [DataCon] -> TypeOfType [A] skipByte :: Peeker () [A] sizeOfRep :: SizeOfRep f => f x -> Int [A] sizeOfMutableByteArray :: MutByteArray -> IO Int [A] sizeOf :: (Unbox a, SizeOfRep (Rep a)) => Proxy a -> Int [A] simplifyDataCon :: DataCon -> SimpleDataCon [A] serializeW8List :: Name -> Name -> [Word8] -> Q Exp [A] serializeConfig :: SerializeConfig [A] serializeAt :: Serialize a => Int -> MutByteArray -> a -> IO Int [A] runPeeker :: Peeker a -> BoundedPtr -> IO a [A] reifyDataType :: Name -> Q DataType [A] readUnsafe :: Unbox a => Peeker a [A] read :: Unbox a => Peeker a [A] putSliceUnsafe :: MonadIO m => MutByteArray -> Int -> MutByteArray -> Int -> Int -> m () [A] pokeRep :: PokeRep f => f a -> BoundedPtr -> IO BoundedPtr [A] pokeBoundedPtrUnsafe :: forall a. Unbox a => a -> BoundedPtr -> IO BoundedPtr [A] pokeBoundedPtr :: forall a. Unbox a => a -> BoundedPtr -> IO BoundedPtr [A] pokeAt :: (Unbox a, Generic a, PokeRep (Rep a)) => Int -> MutByteArray -> a -> IO () [A] pinnedNewAlignedBytes :: Int -> Int -> IO MutByteArray [A] pinnedNew :: Int -> IO MutByteArray [A] pinnedCloneSliceUnsafe :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray [A] pin :: MutByteArray -> IO MutByteArray [A] peekRep :: PeekRep f => Peeker (f x) [A] peekAt :: (Unbox a, Generic a, PeekRep (Rep a)) => Int -> MutByteArray -> IO a [A] openConstructor :: Name -> Int -> Q Pat [A] nil :: MutByteArray [A] newBytesAs :: PinnedState -> Int -> IO MutByteArray [A] new :: Int -> IO MutByteArray [A] mkSerializeExprFields :: Name -> [Field] -> Q Exp [A] mkRecSizeOfExpr :: SimpleDataCon -> Q Exp [A] mkRecSerializeExpr :: Name -> SimpleDataCon -> Q Exp [A] mkRecDeserializeExpr :: Name -> Name -> Name -> SimpleDataCon -> Q Exp [A] mkFieldName :: Int -> Name [A] mkDeserializeKeysDec :: Name -> Name -> SimpleDataCon -> Q [Dec] [A] mkDeserializeExprOne :: Name -> SimpleDataCon -> Q Exp [A] matchConstructor :: Name -> Int -> Q Exp -> Q Match [A] makeN :: Int -> Name [A] makeI :: Int -> Name [A] makeA :: Int -> Name [A] litProxy :: Unbox a => Proxy a -> Q Exp [A] litIntegral :: Integral a => a -> Q Exp [A] isUnitType :: [DataCon] -> Bool [A] isRecordSyntax :: SimpleDataCon -> Bool [A] isPinned :: MutByteArray -> Bool [A] int_w8 :: Int -> Word8 [A] int_w32 :: Int -> Word32 [A] inlineSerializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig [A] inlineDeserializeAt :: Maybe Inline -> SerializeConfig -> SerializeConfig [A] inlineAddSizeTo :: Maybe Inline -> SerializeConfig -> SerializeConfig [A] getMutableByteArray# :: MutByteArray -> MutableByteArray# RealWorld [A] genericSizeOf :: forall a. SizeOfRep (Rep a) => Proxy a -> Int [A] genericPokeByteIndex :: (Generic a, PokeRep (Rep a)) => MutByteArray -> Int -> a -> IO () [A] genericPeekByteIndex :: (Generic a, PeekRep (Rep a)) => MutByteArray -> Int -> IO a [A] errorUnsupported :: String -> a [A] errorUnimplemented :: a [A] encodeRecordFields :: Bool -> SerializeConfig -> SerializeConfig [A] encodeConstrNames :: Bool -> SerializeConfig -> SerializeConfig [A] deserializeAt :: Serialize a => Int -> MutByteArray -> Int -> IO (Int, a) [A] deriveUnbox :: Q [Dec] -> Q [Dec] [A] deriveSerializeWith :: (SerializeConfig -> SerializeConfig) -> Q [Dec] -> Q [Dec] [A] deriveSerialize :: Q [Dec] -> Q [Dec] [A] conUpdateFuncDec :: Name -> [Field] -> Q [Dec] [A] cloneSliceUnsafeAs :: MonadIO m => PinnedState -> Int -> Int -> MutByteArray -> m MutByteArray [A] cloneSliceUnsafe :: MonadIO m => Int -> Int -> MutByteArray -> m MutByteArray [A] c2w :: Char -> Word8 [A] asPtrUnsafe :: MonadIO m => MutByteArray -> (Ptr a -> m b) -> m b [A] addSizeTo :: Serialize a => Int -> a -> Int [A] _x :: Name [A] _val :: Name [A] _tag :: Name [A] _initialOffset :: Name [A] _endOffset :: Name [A] _arr :: Name [A] _acc :: Name [A] Streamly.Internal.Data.MutArray.Stream [A] SpliceState [A] SpliceYielding :: arr -> SpliceState s arr -> SpliceState s arr [A] SpliceInitial :: s -> SpliceState s arr [A] SpliceFinish :: SpliceState s arr [A] SpliceBuffering :: s -> arr -> SpliceState s arr [A] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a)) [A] splitOn :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a) [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a) [A] packArraysChunksOf :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a) [A] lpackArraysChunksOf :: (MonadIO m, Unbox a) => Int -> Fold m (MutArray a) () -> Fold m (MutArray a) () [A] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a) [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a [A] compactLE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (Either ParseError (MutArray a)) [A] compactGE :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a) [A] compactEQ :: Int -> Stream m (MutArray a) -> Stream m (MutArray a) [A] compact :: (MonadIO m, Unbox a) => Int -> Stream m (MutArray a) -> Stream m (MutArray a) [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a) [A] Streamly.Internal.Data.MutArray.Generic [A] MutArray [A] [arrTrueLen] :: MutArray a -> {-# UNPACK #-} !Int [A] [arrStart] :: MutArray a -> {-# UNPACK #-} !Int [A] [arrLen] :: MutArray a -> {-# UNPACK #-} !Int [A] [arrContents#] :: MutArray a -> MutableArray# RealWorld a [A] MutArray :: MutableArray# RealWorld a -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> MutArray a [A] writeWith :: MonadIO m => Int -> Fold m a (MutArray a) [A] writeNUnsafe :: MonadIO m => Int -> Fold m a (MutArray a) [A] writeN :: MonadIO m => Int -> Fold m a (MutArray a) [A] write :: MonadIO m => Fold m a (MutArray a) [A] uninit :: MonadIO m => MutArray a -> Int -> m (MutArray a) [A] toStreamK :: MonadIO m => MutArray a -> StreamK m a [A] toList :: MonadIO m => MutArray a -> m [a] [A] strip :: MonadIO m => (a -> Bool) -> MutArray a -> m (MutArray a) [A] snocWith :: MonadIO m => (Int -> Int) -> MutArray a -> a -> m (MutArray a) [A] snocUnsafe :: MonadIO m => MutArray a -> a -> m (MutArray a) [A] snoc :: MonadIO m => MutArray a -> a -> m (MutArray a) [A] realloc :: MonadIO m => Int -> MutArray a -> m (MutArray a) [A] reader :: MonadIO m => Unfold m (MutArray a) a [A] readRev :: MonadIO m => MutArray a -> Stream m a [A] read :: MonadIO m => MutArray a -> Stream m a [A] putSliceUnsafe :: MonadIO m => MutArray a -> Int -> MutArray a -> Int -> Int -> m () [A] putIndices :: MonadIO m => MutArray a -> Fold m (Int, a) () [A] putIndexUnsafe :: forall m a. MonadIO m => Int -> MutArray a -> a -> m () [A] putIndex :: MonadIO m => Int -> MutArray a -> a -> m () [A] producerWith :: Monad m => (forall b. IO b -> m b) -> Producer m (MutArray a) a [A] producer :: MonadIO m => Producer m (MutArray a) a [A] nil :: MonadIO m => m (MutArray a) [A] new :: MonadIO m => Int -> m (MutArray a) [A] modifyIndexUnsafe :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b [A] modifyIndex :: MonadIO m => Int -> MutArray a -> (a -> (a, b)) -> m b [A] length :: MutArray a -> Int [A] getSliceUnsafe :: Int -> Int -> MutArray a -> MutArray a [A] getSlice :: Int -> Int -> MutArray a -> MutArray a [A] getIndexUnsafeWith :: MonadIO m => MutableArray# RealWorld a -> Int -> m a [A] getIndexUnsafe :: MonadIO m => Int -> MutArray a -> m a [A] getIndex :: MonadIO m => Int -> MutArray a -> m (Maybe a) [A] fromStreamN :: MonadIO m => Int -> Stream m a -> m (MutArray a) [A] fromStream :: MonadIO m => Stream m a -> m (MutArray a) [A] fromPureStream :: MonadIO m => Stream Identity a -> m (MutArray a) [A] fromListN :: MonadIO m => Int -> [a] -> m (MutArray a) [A] fromList :: MonadIO m => [a] -> m (MutArray a) [A] eq :: (MonadIO m, Eq a) => MutArray a -> MutArray a -> m Bool [A] cmp :: (MonadIO m, Ord a) => MutArray a -> MutArray a -> m Ordering [A] clone :: MonadIO m => MutArray a -> m (MutArray a) [A] chunksOf :: forall m a. MonadIO m => Int -> Stream m a -> Stream m (MutArray a) [A] Streamly.Internal.Data.MutArray [A] MutByteArray [A] MutArray [A] [arrStart] :: MutArray a -> {-# UNPACK #-} !Int [A] [arrEnd] :: MutArray a -> {-# UNPACK #-} !Int [A] [arrContents] :: MutArray a -> {-# UNPACK #-} !MutByteArray [A] [arrBound] :: MutArray a -> {-# UNPACK #-} !Int [A] MutArray :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> MutArray a [A] IORef [A] ArrayUnsafe [A] ArrayUnsafe :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> ArrayUnsafe a [A] writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a) [A] writeRevN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a) [A] writeNWithUnsafe :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a) [A] writeNWith :: forall m a. (MonadIO m, Unbox a) => (Int -> m (MutArray a)) -> Int -> Fold m a (MutArray a) [A] writeNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a) [A] writeN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a) [A] writeIORef :: Unbox a => IORef a -> a -> IO () [A] writeChunks :: (MonadIO m, Unbox a) => Int -> Fold m a (StreamK n (MutArray a)) [A] writeAppendWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> m (MutArray a) -> Fold m a (MutArray a) [A] writeAppendNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a) [A] writeAppendN :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) -> Fold m a (MutArray a) [A] writeAppend :: forall m a. (MonadIO m, Unbox a) => m (MutArray a) -> Fold m a (MutArray a) [A] write :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a) [A] unsafeSwapIndices :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> MutArray a -> m () [A] unpin :: MutArray a -> IO (MutArray a) [A] toStreamKWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> StreamK m a [A] toStreamKRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> StreamK m a [A] toStreamKRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> StreamK m a [A] toStreamK :: forall m a. (MonadIO m, Unbox a) => MutArray a -> StreamK m a [A] toStreamDWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a [A] toStreamDRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> MutArray a -> Stream m a [A] toList :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m [a] [A] swapIndices :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> MutArray a -> m () [A] strip :: forall a m. (Unbox a, MonadIO m) => (a -> Bool) -> MutArray a -> m (MutArray a) [A] splitOn :: (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> Stream m (MutArray a) [A] splitAt :: forall a. Unbox a => Int -> MutArray a -> (MutArray a, MutArray a) [A] spliceWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int -> Int) -> MutArray a -> MutArray a -> m (MutArray a) [A] spliceUnsafe :: MonadIO m => MutArray a -> MutArray a -> m (MutArray a) [A] spliceExp :: (MonadIO m, Unbox a) => MutArray a -> MutArray a -> m (MutArray a) [A] spliceCopy :: forall m a. MonadIO m => MutArray a -> MutArray a -> m (MutArray a) [A] splice :: (MonadIO m, Unbox a) => MutArray a -> MutArray a -> m (MutArray a) [A] snocWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int) -> MutArray a -> a -> m (MutArray a) [A] snocUnsafe :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a) [A] snocMay :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (Maybe (MutArray a)) [A] snocLinear :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a) [A] snoc :: forall m a. (MonadIO m, Unbox a) => MutArray a -> a -> m (MutArray a) [A] shuffleBy :: (a -> a -> m Bool) -> MutArray a -> MutArray a -> m () [A] roundUpToPower2 :: Int -> Int [A] rightSize :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m (MutArray a) [A] reverse :: forall m a. (MonadIO m, Unbox a) => MutArray a -> m () [A] resizeExp :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a) [A] resize :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a) [A] realloc :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (MutArray a) [A] readerRevWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> Unfold m (MutArray a) a [A] readerRev :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a [A] reader :: forall m a. (MonadIO m, Unbox a) => Unfold m (MutArray a) a [A] readRev :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a [A] readIORef :: Unbox a => IORef a -> IO a [A] read :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Stream m a [A] putIndices :: forall m a. (MonadIO m, Unbox a) => MutArray a -> Fold m (Int, a) () [A] putIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m () [A] putIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> a -> m () [A] producerWith :: forall m a. (Monad m, Unbox a) => (forall b. IO b -> m b) -> Producer m (MutArray a) a [A] producer :: forall m a. (MonadIO m, Unbox a) => Producer m (MutArray a) a [A] pollIntIORef :: (MonadIO m, Unbox a) => IORef a -> Stream m a [A] pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a) [A] pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (MutArray a) [A] pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (MutArray a) [A] pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (MutArray a) [A] pinnedNewBytes :: MonadIO m => Int -> m (MutArray a) [A] pinnedNewAligned :: (MonadIO m, Unbox a) => Int -> Int -> m (MutArray a) [A] pinnedNew :: forall m a. (MonadIO m, Unbox a) => Int -> m (MutArray a) [A] pinnedFromListN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a) [A] pinnedFromList :: (MonadIO m, Unbox a) => [a] -> m (MutArray a) [A] pinnedClone :: MonadIO m => MutArray a -> m (MutArray a) [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (MutArray a) [A] pin :: MutArray a -> IO (MutArray a) [A] permute :: MutArray a -> m Bool [A] partitionBy :: forall m a. (MonadIO m, Unbox a) => (a -> Bool) -> MutArray a -> m (MutArray a, MutArray a) [A] nil :: MutArray a [A] newIORef :: forall a. Unbox a => a -> IO (IORef a) [A] newArrayWith :: forall m a. (MonadIO m, Unbox a) => (Int -> Int -> m MutByteArray) -> Int -> Int -> m (MutArray a) [A] new :: (MonadIO m, Unbox a) => Int -> m (MutArray a) [A] modifyIndices :: forall m a. (MonadIO m, Unbox a) => MutArray a -> (Int -> a -> a) -> Fold m Int () [A] modifyIndexUnsafe :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b [A] modifyIndex :: forall m a b. (MonadIO m, Unbox a) => Int -> MutArray a -> (a -> (a, b)) -> m b [A] modifyIORef' :: Unbox a => IORef a -> (a -> a) -> IO () [A] modify :: forall m a. (MonadIO m, Unbox a) => MutArray a -> (a -> a) -> m () [A] mergeBy :: Int -> (MutArray a -> MutArray a -> m ()) -> MutArray a -> m () [A] memcpy :: Ptr Word8 -> Ptr Word8 -> Int -> IO () [A] memcmp :: Ptr Word8 -> Ptr Word8 -> Int -> IO Bool [A] length :: forall a. Unbox a => MutArray a -> Int [A] isPinned :: MutArray a -> Bool [A] getSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (MutArray a) [A] getSliceUnsafe :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a [A] getSlice :: forall a. Unbox a => Int -> Int -> MutArray a -> MutArray a [A] getIndicesD :: (Monad m, Unbox a) => (forall b. IO b -> m b) -> Stream m Int -> Unfold m (MutArray a) a [A] getIndices :: (MonadIO m, Unbox a) => Stream m Int -> Unfold m (MutArray a) a [A] getIndexUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a [A] getIndexRev :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m a [A] getIndex :: forall m a. (MonadIO m, Unbox a) => Int -> MutArray a -> m (Maybe a) [A] genSlicesFromLen :: forall m a. (Monad m, Unbox a) => Int -> Int -> Unfold m (MutArray a) (Int, Int) [A] fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (MutArray a) [A] fromStreamD :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a) [A] fromStream :: (MonadIO m, Unbox a) => Stream m a -> m (MutArray a) [A] fromPureStream :: (MonadIO m, Unbox a) => Stream Identity a -> m (MutArray a) [A] fromListRevN :: (MonadIO m, Unbox a) => Int -> [a] -> m (MutArray a) [A] fromListRev :: (MonadIO m, Unbox a) => [a] -> 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] fromArrayStreamK :: (Unbox a, MonadIO m) => StreamK m (MutArray a) -> m (MutArray a) [A] foldr :: (MonadIO m, Unbox a) => (a -> b -> b) -> b -> MutArray a -> m b [A] foldl' :: (MonadIO m, Unbox a) => (b -> a -> b) -> b -> MutArray a -> m b [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (MutArray a) -> Stream m a [A] divideBy :: Int -> (MutArray a -> m (MutArray a, MutArray a)) -> MutArray a -> m () [A] cmp :: MonadIO m => MutArray a -> MutArray a -> m Ordering [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] castUnsafe :: MutArray a -> MutArray b [A] cast :: forall a b. Unbox b => MutArray a -> Maybe (MutArray b) [A] c_memchr :: Ptr Word8 -> Word8 -> CSize -> IO (Ptr Word8) [A] bytesFree :: MutArray a -> Int [A] byteLength :: MutArray a -> Int [A] byteCapacity :: MutArray a -> Int [A] bubble :: (MonadIO m, Unbox a) => (a -> a -> Ordering) -> MutArray a -> m () [A] breakOn :: MonadIO m => Word8 -> MutArray Word8 -> m (MutArray Word8, Maybe (MutArray Word8)) [A] blockSize :: Int [A] asPtrUnsafe :: MonadIO m => MutArray a -> (Ptr a -> m b) -> m b [A] asBytes :: MutArray a -> MutArray Word8 [A] arrayChunkBytes :: Int [A] allocBytesToElemCount :: Unbox a => a -> Int -> Int [C] Streamly.Internal.Data.IsMap [A] mapTraverseWithKey :: (IsMap f, Applicative t) => (Key f -> a -> t b) -> f a -> t (f b) [R] Streamly.Internal.Data.IORef.Unboxed [R] Streamly.Internal.Data.Fold.Window [R] Streamly.Internal.Data.Fold.Type [R] Streamly.Internal.Data.Fold.Tee [R] Streamly.Internal.Data.Fold.Step [R] Streamly.Internal.Data.Fold.Container [D] Streamly.Internal.Data.Fold.Chunked [C] Streamly.Internal.Data.Fold [A] ManyState [C] Fold [C] Fold [O] Fold :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> Fold m a b [N] Fold :: (s -> a -> m (Step s b)) -> m (Step s b) -> (s -> m b) -> (s -> m b) -> Fold m a b [A] windowSumInt :: forall m a. (Monad m, Integral a) => Fold m (a, Maybe a) a [A] windowSum :: forall m a. (Monad m, Num a) => Fold m (a, Maybe a) a [A] windowRollingMapM :: Monad m => (Maybe a -> a -> m (Maybe b)) -> Fold m (a, Maybe a) (Maybe b) [A] windowRollingMap :: Monad m => (Maybe a -> a -> Maybe b) -> Fold m (a, Maybe a) (Maybe b) [A] windowRange :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe (a, a)) [A] windowPowerSumFrac :: (Monad m, Floating a) => a -> Fold m (a, Maybe a) a [A] windowPowerSum :: (Monad m, Num a) => Int -> Fold m (a, Maybe a) a [A] windowMinimum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a) [A] windowMean :: forall m a. (Monad m, Fractional a) => Fold m (a, Maybe a) a [A] windowMaximum :: (MonadIO m, Storable a, Ord a) => Int -> Fold m a (Maybe a) [A] windowLmap :: (c -> a) -> Fold m (a, Maybe a) b -> Fold m (c, Maybe c) b [A] windowLength :: (Monad m, Num b) => Fold m (a, Maybe a) b [A] toSet :: (Monad m, Ord a) => Fold m a (Set a) [A] toMapIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b) [A] toMap :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (Map k b) [A] toIntSet :: Monad m => Fold m Int IntSet [A] toContainerIO :: (MonadIO m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (f b) [A] toContainer :: (Monad m, IsMap f, Traversable f, Ord (Key f)) => (a -> Key f) -> Fold m a b -> Fold m a (f b) [A] nubInt :: Monad m => Fold m Int (Maybe Int) [A] nub :: (Monad m, Ord a) => Fold m a (Maybe a) [A] mapMStep :: Applicative m => (a -> m b) -> Step s a -> m (Step s b) [A] kvToMap :: (Monad m, Ord k) => Fold m a b -> Fold m (k, a) (Map k b) [A] frequency :: (Monad m, Ord a) => Fold m a (Map a Int) [A] demuxToMapIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b) [A] demuxToMap :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (Map k b) [A] demuxToContainerIO :: (MonadIO m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b) [A] demuxToContainer :: (Monad m, IsMap f, Traversable f) => (a -> Key f) -> (a -> m (Fold m a b)) -> Fold m a (f b) [A] demuxKvToMap :: (Monad m, Ord k) => (k -> m (Fold m a b)) -> Fold m (k, a) (Map k b) [A] demuxKvToContainer :: (Monad m, IsMap f, Traversable f) => (Key f -> m (Fold m a b)) -> Fold m (Key f, a) (f b) [A] demuxIO :: (MonadIO m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b)) [A] 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)) [A] 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)) [A] demux :: (Monad m, Ord k) => (a -> k) -> (a -> m (Fold m a b)) -> Fold m a (m (Map k b), Maybe (k, b)) [A] cumulative :: Fold m (a, Maybe a) b -> Fold m a b [A] countDistinctInt :: Monad m => Fold m Int Int [A] countDistinct :: (Monad m, Ord a) => Fold m a Int [A] classifyIO :: (MonadIO m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b)) [A] 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)) [A] 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)) [A] classify :: (Monad m, Ord k) => (a -> k) -> Fold m a b -> Fold m a (m (Map k b), Maybe (k, b)) [A] chainStepM :: Applicative m => (s1 -> m s2) -> (a -> m (Step s2 b)) -> Step s1 a -> m (Step s2 b) [C] Streamly.Internal.Data.Builder [C] Builder [C] Builder [O] Builder :: (s -> m (s, a)) -> Builder s m a [N] Builder :: (s -> m (a, s)) -> Builder s m a [A] Streamly.Internal.Data.Binary.Stream [A] class ToBytes a [A] word8 :: Applicative m => Word8 -> Stream m Word8 [A] word64le :: Monad m => Word64 -> Stream m Word8 [A] word64host :: Monad m => Word64 -> Stream m Word8 [A] word64be :: Monad m => Word64 -> Stream m Word8 [A] word32le :: Monad m => Word32 -> Stream m Word8 [A] word32be :: Monad m => Word32 -> Stream m Word8 [A] word16le :: Monad m => Word16 -> Stream m Word8 [A] word16be :: Monad m => Word16 -> Stream m Word8 [A] unit :: Applicative m => Stream m Word8 [A] toBytes :: ToBytes a => a -> Stream m Word8 [A] ordering :: Applicative m => Ordering -> Stream m Word8 [A] int8 :: Applicative m => Int8 -> Stream m Word8 [A] int64le :: Monad m => Int64 -> Stream m Word8 [A] int64be :: Monad m => Int64 -> Stream m Word8 [A] int32le :: Monad m => Int32 -> Stream m Word8 [A] int32be :: Monad m => Int32 -> Stream m Word8 [A] int16le :: Monad m => Int16 -> Stream m Word8 [A] int16be :: Monad m => Int16 -> Stream m Word8 [A] float32le :: Monad m => Float -> Stream m Word8 [A] float32be :: Monad m => Float -> Stream m Word8 [A] double64le :: Monad m => Double -> Stream m Word8 [A] double64be :: Monad m => Double -> Stream m Word8 [A] charUtf8 :: Monad m => Char -> Stream m Word8 [A] charLatin1 :: Applicative m => Char -> Stream m Word8 [A] bool :: Applicative m => Bool -> Stream m Word8 [A] Streamly.Internal.Data.Binary.Parser [A] class FromBytes a [A] word8 :: Monad m => Parser Word8 m Word8 [A] word64le :: Monad m => Parser Word8 m Word64 [A] word64host :: MonadIO m => Parser Word8 m Word64 [A] word64be :: Monad m => Parser Word8 m Word64 [A] word32le :: Monad m => Parser Word8 m Word32 [A] word32be :: Monad m => Parser Word8 m Word32 [A] word16le :: Monad m => Parser Word8 m Word16 [A] word16be :: Monad m => Parser Word8 m Word16 [A] unit :: Monad m => Parser Word8 m () [A] ordering :: Monad m => Parser Word8 m Ordering [A] int8 :: Monad m => Parser Word8 m Int8 [A] int64le :: Monad m => Parser Word8 m Int64 [A] int64be :: Monad m => Parser Word8 m Int64 [A] int32le :: Monad m => Parser Word8 m Int32 [A] int32be :: Monad m => Parser Word8 m Int32 [A] int16le :: Monad m => Parser Word8 m Int16 [A] int16be :: Monad m => Parser Word8 m Int16 [A] fromBytes :: FromBytes a => Parser Word8 m a [A] float32le :: MonadIO m => Parser Word8 m Float [A] float32be :: MonadIO m => Parser Word8 m Float [A] eqWord8 :: Monad m => Word8 -> Parser Word8 m Word8 [A] double64le :: MonadIO m => Parser Word8 m Double [A] double64be :: MonadIO m => Parser Word8 m Double [A] charLatin1 :: Monad m => Parser Word8 m Char [A] bool :: Monad m => Parser Word8 m Bool [R] Streamly.Internal.Data.Array.Type [A] Streamly.Internal.Data.Array.Stream [A] unlines :: forall m a. (MonadIO m, Unbox a) => a -> Stream m (Array a) -> Stream m a [A] toArray :: (MonadIO m, Unbox a) => Stream m (Array a) -> m (Array a) [A] splitOnSuffix :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8) [A] splitOn :: MonadIO m => Word8 -> Stream m (Array Word8) -> Stream m (Array Word8) [A] runArrayParserDBreak :: forall m a b. (MonadIO m, Unbox a) => Parser (Array a) m b -> Stream m (Array a) -> m (Either ParseError b, Stream m (Array a)) [A] runArrayFoldMany :: (Monad m, Unbox a) => ChunkFold m a b -> StreamK m (Array a) -> StreamK m (Either ParseError b) [A] runArrayFoldBreak :: (MonadIO m, Unbox a) => ChunkFold m a b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [A] runArrayFold :: (MonadIO m, Unbox a) => ChunkFold m a b -> StreamK m (Array a) -> m (Either ParseError b) [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a) [A] parseChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b) [A] parseBreakChunks :: (Monad m, Unbox a) => ParserK (Array a) m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [A] parseBreak :: (MonadIO m, Unbox a) => Parser a m b -> StreamK m (Array a) -> m (Either ParseError b, StreamK m (Array a)) [A] lpackArraysChunksOf :: (MonadIO m, Unbox a) => Int -> Fold m (Array a) () -> Fold m (Array a) () [A] interposeSuffix :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a [A] interpose :: (Monad m, Unbox a) => a -> Stream m (Array a) -> Stream m a [A] intercalateSuffix :: (Monad m, Unbox a) => Array a -> Stream m (Array a) -> Stream m a [A] foldBreakD :: forall m a b. (MonadIO m, Unbox a) => Fold m a b -> Stream m (Array a) -> m (b, Stream m (Array a)) [A] foldBreak :: (MonadIO m, Unbox a) => Fold m a b -> StreamK m (Array a) -> m (b, StreamK m (Array a)) [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a [A] concatRev :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a [A] concat :: (Monad m, Unbox a) => Stream m (Array a) -> Stream m a [A] compact :: (MonadIO m, Unbox a) => Int -> Stream m (Array a) -> Stream m (Array a) [A] chunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a) [A] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a)) [R] Streamly.Internal.Data.Array.Mut.Type [R] Streamly.Internal.Data.Array.Mut.Stream [R] Streamly.Internal.Data.Array.Mut [R] Streamly.Internal.Data.Array.Generic.Mut.Type [C] Streamly.Internal.Data.Array.Generic [A] getIndex :: Int -> Array a -> Maybe a [A] fromPureStream :: Stream Identity a -> Array a [A] fromByteStr# :: Addr# -> Array Word8 [A] chunksOf :: forall m a. MonadIO m => Int -> Stream m a -> Stream m (Array a) [C] Streamly.Internal.Data.Array [A] ArrayUnsafe [A] ArrayUnsafe :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> ArrayUnsafe a [C] Array [A] [arrStart] :: Array a -> {-# UNPACK #-} !Int [A] [arrEnd] :: Array a -> {-# UNPACK #-} !Int [A] [arrContents] :: Array a -> {-# UNPACK #-} !MutByteArray [A] Array :: {-# UNPACK #-} !MutByteArray -> {-# UNPACK #-} !Int -> {-# UNPACK #-} !Int -> Array a [A] writeWith :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a) [A] writeNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a) [R] writeNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (Array a) [A] unsafeMakePure :: Monad m => Fold IO a b -> Fold m a b [A] unsafeIndexIO :: forall a. Unbox a => Int -> Array a -> IO a [D] unsafeIndex :: forall a. Unbox a => Int -> Array a -> a [A] unsafeFreezeWithShrink :: Unbox a => MutArray a -> Array a [A] unpin :: Array a -> IO (Array a) [A] toStreamKRev :: forall m a. (Monad m, Unbox a) => Array a -> StreamK m a [A] toStreamK :: forall m a. (Monad m, Unbox a) => Array a -> StreamK m a [A] toStreamDRev :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a [A] toStreamD :: forall m a. (Monad m, Unbox a) => Array a -> Stream m a [A] splitAt :: Unbox a => Int -> Array a -> (Array a, Array a) [A] splice :: (MonadIO m, Unbox a) => Array a -> Array a -> m (Array a) [A] serialize :: Serialize a => a -> Array Word8 [A] pinnedWriteNUnsafe :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a) [A] pinnedWriteNAligned :: forall m a. (MonadIO m, Unbox a) => Int -> Int -> Fold m a (Array a) [A] pinnedWriteN :: forall m a. (MonadIO m, Unbox a) => Int -> Fold m a (Array a) [A] pinnedWrite :: forall m a. (MonadIO m, Unbox a) => Fold m a (Array a) [A] pinnedSerialize :: Serialize a => a -> Array Word8 [A] pinnedFromListN :: Unbox a => Int -> [a] -> Array a [A] pinnedFromList :: Unbox a => [a] -> Array a [A] pinnedClone :: MonadIO m => Array a -> m (Array a) [A] pinnedChunksOf :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> Stream m (Array a) [A] pin :: Array a -> IO (Array a) [A] nil :: Array a [A] isPinned :: Array a -> Bool [A] getIndexUnsafe :: forall a. Unbox a => Int -> Array a -> a [A] fromStreamDN :: forall m a. (MonadIO m, Unbox a) => Int -> Stream m a -> m (Array a) [A] fromStreamD :: forall m a. (MonadIO m, Unbox a) => Stream m a -> m (Array a) [A] fromPureStream :: Unbox a => Stream Identity a -> Array a [A] fromListRevN :: Unbox a => Int -> [a] -> Array a [A] fromListRev :: Unbox a => [a] -> Array a [A] fromByteStr# :: Addr# -> Array Word8 [A] foldr :: Unbox a => (a -> b -> b) -> b -> Array a -> b [A] foldl' :: forall a b. Unbox a => (b -> a -> b) -> b -> Array a -> b [A] flattenArraysRev :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a [A] flattenArrays :: forall m a. (MonadIO m, Unbox a) => Stream m (Array a) -> Stream m a [A] encodeAs :: forall a. Serialize a => PinnedState -> a -> Array Word8 [A] deserialize :: Serialize a => Array Word8 -> a [A] 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] byteLength :: Array a -> Int [A] bufferChunks :: (MonadIO m, Unbox a) => Stream m a -> m (StreamK m (Array a)) [A] breakOn :: MonadIO m => Word8 -> Array Word8 -> m (Array Word8, Maybe (Array Word8))