-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | An alternate with strong-typed errors for `Data.Binary.Get` monad from `binary` package.
--   
--   An alternate with strong-typed errors for <a>Data.Binary.Get</a> monad
--   from <a>binary</a> package.
@package binary-ext
@version 2.0.4


-- | This module provides generic functions set useful for
--   errortype-parameterized monads and monad transformers, such as
--   <a>Get</a>. Example:
--   
--   <pre>
--   pSign :: Parser (Maybe Char) Bool
--   pSign = do
--     c &lt;- pChar ?&gt;&gt; return Nothing
--     case c of
--       '+' -&gt; return False
--       '-' -&gt; return True
--       x -&gt; throwError (Just x)
--   
--   pSignedNumber :: Parser String Int
--   pSignedNumber = do
--     is_negative &lt;- fromMaybe False &lt;$&gt; option'' pSign
--     value &lt;- foldl1 (\ !a !b -&gt; a * 10 + b) &lt;$&gt; many1'' pDigit ?&gt;&gt; return "digit or sign expected"
--     return $ if is_negative then -value else value
--   </pre>
module Control.Monad.Error.Map
class (MonadError e m_e, MonadError e' m_e') => MonadMapError e m_e e' m_e' | m_e -> e, m_e' -> e', m_e e' -> m_e', m_e' e -> m_e
mapError :: MonadMapError e m_e e' m_e' => (e -> e') -> m_e a -> m_e' a
(?=>>) :: (MonadMapError e m_e (Either e e') m_Either_e_e', MonadMapError Void m_Void (Either e e') m_Either_e_e', MonadMapError (Either e e') m_Either_e_e' e' m_e') => m_e a -> (e -> m_Void e') -> m_e' a
infixl 1 ?=>>
(?>>) :: (MonadMapError () m_Unit (Maybe e) m_Maybe_e, MonadMapError Void m_Void (Maybe e) m_Maybe_e, MonadMapError (Maybe e) m_Maybe_e e m_e) => m_Unit a -> m_Void e -> m_e a
infixl 1 ?>>
option'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' (Maybe a)
many'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' [a]
many1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e (NonEmpty a)
manyTill'' :: (MonadPlus m_Unit, MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e' b -> m_e [a]
sepBy'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e'' m_e'', MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit () m_Unit) => m_e a -> m_e' s -> m_e'' [a]
sepBy1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e, MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit () m_Unit) => m_e a -> m_e' s -> m_e (NonEmpty a)
skipMany'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' ()
skipMany1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e ()
instance Control.Monad.Error.Map.MonadMapError e (Data.Either.Either e) e' (Data.Either.Either e')
instance GHC.Base.Monad m => Control.Monad.Error.Map.MonadMapError e (Control.Monad.Trans.Except.ExceptT e m) e' (Control.Monad.Trans.Except.ExceptT e' m)
instance Control.Monad.Error.Map.MonadMapError e m_e e' m_e' => Control.Monad.Error.Map.MonadMapError e (Data.Conduit.Internal.Conduit.ConduitT i o m_e) e' (Data.Conduit.Internal.Conduit.ConduitT i o m_e')


-- | This module provides the <a>GetC</a> monad transformer, and all
--   functions, which could not be defined using <a>GetC</a> public
--   interface only.
module Data.Conduit.Parsers.GetC
class DecodingState s where {
    type family DecodingToken s :: *;
}
decoded :: DecodingState s => DecodingToken s -> s -> s

-- | <a>GetC</a> monad state.
data Decoding s i

-- | Construct <a>GetC</a> initial state.
startDecoding :: s -> Decoding s i

-- | Adjust <a>GetC</a> state. This is low-level function, not supposed to
--   directly use.
continueDecoding :: s -> [i] -> Decoding s i -> Decoding s i

-- | Get the total number of bytes read to this point.
decodingRead :: Decoding s i -> s

-- | Internal transformers for <a>GetT</a> with error type <tt>e</tt>, base
--   monad <tt>m</tt>, and decoder result <tt>a</tt>.
data GetC s i e m a

-- | A <a>ConduitT</a> with internal transformers supposed to a binary
--   deserialization.
type GetT s i o e m = ConduitT i o (GetC s i e m)

-- | Run a <a>GetT</a> monad, unwrapping all internal transformers in a
--   reversible way.
--   
--   <pre>
--   <a>getC</a> . <a>flip</a> runGetC = <a>id</a>
--   </pre>
runGetC :: Monad m => Decoding s i -> GetT s i o e m a -> ConduitT i o m (Either e a, Decoding s i)

-- | Custom <a>GetT</a>.
--   
--   <pre>
--   getC . <a>flip</a> <a>runGetC</a> = <a>id</a>
--   </pre>
--   
--   Example (<a>Get</a> is a shortening of <a>GetT</a>):
--   
--   <pre>
--   skipUntilZero :: Get e Bool
--   skipUntilZero = getC $ flip runStateC $ untilJust $ do
--     !m_inp &lt;- await
--     case m_inp of
--       Nothing -&gt; return $ Just $ Right False
--       Just !inp -&gt; do
--         case SB.elemIndex 0 inp of
--           Nothing -&gt; do
--             lift $ modify' $ decoded inp
--             return Nothing
--           Just !i -&gt; do
--             let (!h, !t) = SB.splitAt i inp
--             leftover t
--             lift $ modify' $ decoded h
--             return $ Just $ Right True
--   </pre>
getC :: Monad m => (Decoding s i -> ConduitT i o m (Either e a, Decoding s i)) -> GetT s i o e m a

-- | Run a decoder, storing input stream.
trackP :: Monad m => GetT s i o e m a -> GetT s i o ([i], e) m ([i], a)

-- | Leftover consumed input on error.
tryP :: Monad m => GetT s i o e m a -> GetT s i o e m a

-- | Wrap the base monad in <a>ExceptT</a>, pushing <a>Maybe</a> to a monad
--   transformers stack.
maybeG :: Monad m => GetT s i o e m (Maybe a) -> GetT s i o e (ExceptT (Decoding s i) m) a

-- | Run <a>ExceptT</a> in the base monad, pulling <a>Maybe</a> from a
--   monad transformers stack.
runMaybeG :: Monad m => GetT s i o e (ExceptT (Decoding s i) m) a -> GetT s i o e m (Maybe a)

-- | Wrap the base monad in <a>ExceptT</a>, pushing <a>Either</a> to a
--   monad transformers stack.
exceptG :: Monad m => GetT s i o e' m (Either e a) -> GetT s i o e' (ExceptT (e, Decoding s i) m) a

-- | Run <a>ExceptT</a> in the base monad, pulling <a>Either</a> from a
--   monad transformers stack.
runExceptG :: Monad m => GetT s i o e' (ExceptT (e, Decoding s i) m) a -> GetT s i o e' m (Either e a)

-- | Catch an error in the base monad.
catchExceptG :: Monad m => GetT s i o e' (ExceptT (e, Decoding s i) m) r -> (e -> GetT s i o e' (ExceptT (e, Decoding s i) m) r) -> GetT s i o e' (ExceptT (e, Decoding s i) m) r

-- | Wrap the base monad in <a>ReaderT</a>.
readerG :: Monad m => (r -> GetT s i o e m a) -> GetT s i o e (ReaderT r m) a

-- | Run <a>ReaderT</a> in the base monad.
runReaderG :: Monad m => r -> GetT s i o e (ReaderT r m) a -> GetT s i o e m a

-- | Wrap the base monad in <a>StateT</a>.
stateLG :: Monad m => (t -> GetT s i o e m (a, t)) -> GetT s i o e (StateT t m) a

-- | Run <a>StateT</a> in the base monad.
runStateLG :: Monad m => t -> GetT s i o e (StateT t m) a -> GetT s i o e m (a, t)

-- | Evaluate <a>StateT</a> in the base monad.
evalStateLG :: Monad m => t -> GetT s i o e (StateT t m) a -> GetT s i o e m a

-- | Execute <a>StateT</a> in the base monad.
execStateLG :: Monad m => t -> GetT s i o e (StateT t m) a -> GetT s i o e m t

-- | Wrap the base monad in <a>StateT</a>.
stateG :: Monad m => (t -> GetT s i o e m (a, t)) -> GetT s i o e (StateT t m) a

-- | Run <a>StateT</a> in the base monad.
runStateG :: Monad m => t -> GetT s i o e (StateT t m) a -> GetT s i o e m (a, t)

-- | Evaluate <a>StateT</a> in the base monad.
evalStateG :: Monad m => t -> GetT s i o e (StateT t m) a -> GetT s i o e m a

-- | Execute <a>StateT</a> in the base monad.
execStateG :: Monad m => t -> GetT s i o e (StateT t m) a -> GetT s i o e m t

-- | Wrap the base monad in <a>WriterT</a>.
writerLG :: (Monad m, Monoid t) => GetT s i o e m (a, t) -> GetT s i o e (WriterT t m) a

-- | Run <a>WriterT</a> in the base monad.
runWriterLG :: (Monad m, Monoid t) => GetT s i o e (WriterT t m) a -> GetT s i o e m (a, t)

-- | Execute <a>WriterT</a> in the base monad.
execWriterLG :: (Monad m, Monoid t) => GetT s i o e (WriterT t m) a -> GetT s i o e m t

-- | Wrap the base monad in <a>WriterT</a>.
writerG :: (Monad m, Monoid t) => GetT s i o e m (a, t) -> GetT s i o e (WriterT t m) a

-- | Run <a>WriterT</a> in the base monad.
runWriterG :: (Monad m, Monoid t) => GetT s i o e (WriterT t m) a -> GetT s i o e m (a, t)

-- | Execute <a>WriterT</a> in the base monad.
execWriterG :: (Monad m, Monoid t) => GetT s i o e (WriterT t m) a -> GetT s i o e m t

-- | Wrap the base monad in <a>RWST</a>.
rwsLG :: (Monad m, Monoid w) => (r -> t -> GetT s i o e m (a, t, w)) -> GetT s i o e (RWST r w t m) a

-- | Run <a>RWST</a> in the base monad.
runRWSLG :: (Monad m, Monoid w) => r -> t -> GetT s i o e (RWST r w t m) a -> GetT s i o e m (a, t, w)

-- | Evaluate <a>RWST</a> in the base monad.
evalRWSLG :: (Monad m, Monoid w) => r -> t -> GetT s i o e (RWST r w t m) a -> GetT s i o e m (a, w)

-- | Execute <a>RWST</a> in the base monad.
execRWSLG :: (Monad m, Monoid w) => r -> t -> GetT s i o e (RWST r w t m) a -> GetT s i o e m (t, w)

-- | Wrap the base monad in <a>RWST</a>.
rwsG :: (Monad m, Monoid w) => (r -> t -> GetT s i o e m (a, t, w)) -> GetT s i o e (RWST r w t m) a

-- | Run <a>RWST</a> in the base monad.
runRWSG :: (Monad m, Monoid w) => r -> t -> GetT s i o e (RWST r w t m) a -> GetT s i o e m (a, t, w)

-- | Evaluate <a>RWST</a> in the base monad.
evalRWSG :: (Monad m, Monoid w) => r -> t -> GetT s i o e (RWST r w t m) a -> GetT s i o e m (a, w)

-- | Execute <a>RWST</a> in the base monad.
execRWSG :: (Monad m, Monoid w) => r -> t -> GetT s i o e (RWST r w t m) a -> GetT s i o e m (t, w)
instance GHC.Base.Monad m => GHC.Base.Monad (Data.Conduit.Parsers.GetC.GetC s i e m)
instance GHC.Base.Functor m => GHC.Base.Functor (Data.Conduit.Parsers.GetC.GetC s i e m)
instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Data.Conduit.Parsers.GetC.GetC s i e m)
instance Control.Monad.Fail.MonadFail m => Control.Monad.Fail.MonadFail (Data.Conduit.Parsers.GetC.GetC s i e m)
instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Data.Conduit.Parsers.GetC.GetC s i e m)
instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.Conduit.Parsers.GetC.GetC s i e m)
instance (GHC.Base.Functor m, GHC.Base.Monad m, GHC.Base.Monoid e) => GHC.Base.Alternative (Data.Conduit.Parsers.GetC.GetC s i e m)
instance (GHC.Base.Monad m, GHC.Base.Monoid e) => GHC.Base.MonadPlus (Data.Conduit.Parsers.GetC.GetC s i e m)
instance GHC.Base.Monad m => Control.Monad.Error.Class.MonadError e (Data.Conduit.Parsers.GetC.GetC s i e m)
instance (GHC.Base.Monoid e, GHC.Base.Monad m) => GHC.Base.Alternative (Data.Conduit.Parsers.GetC.GetT s i o e m)
instance (GHC.Base.Monoid e, GHC.Base.Monad m) => GHC.Base.MonadPlus (Data.Conduit.Parsers.GetC.GetT s i o e m)
instance Control.Monad.Trans.Class.MonadTrans (Data.Conduit.Parsers.GetC.GetC s i e)
instance Control.Monad.Trans.Control.MonadTransControl (Data.Conduit.Parsers.GetC.GetC s i e)
instance Control.Monad.Base.MonadBase b m => Control.Monad.Base.MonadBase b (Data.Conduit.Parsers.GetC.GetC s i e m)
instance Control.Monad.Trans.Control.MonadBaseControl b m => Control.Monad.Trans.Control.MonadBaseControl b (Data.Conduit.Parsers.GetC.GetC s i e m)
instance GHC.Base.Monad m => Control.Monad.Error.Map.MonadMapError e (Data.Conduit.Parsers.GetC.GetC s i e m) e' (Data.Conduit.Parsers.GetC.GetC s i e' m)
instance (Data.Conduit.Parsers.GetC.DecodingState s, Data.Conduit.Parsers.GetC.DecodingToken s ~ i) => Data.Conduit.Parsers.GetC.DecodingState (Data.Conduit.Parsers.GetC.Decoding s i)

module Data.Conduit.Parsers

-- | <tt>choice ps</tt> tries to apply the actions in the list <tt>ps</tt>
--   in order, until one of them succeeds. Returns the value of the
--   succeeding action.
choice :: Alternative f => [f a] -> f a

-- | Apply the given action repeatedly, returning every result.
count :: Monad m => Int -> m a -> m [a]
option'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' (Maybe a)
many'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' [a]
many1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e (NonEmpty a)
manyTill'' :: (MonadPlus m_Unit, MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e' b -> m_e [a]
sepBy'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e'' m_e'', MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit () m_Unit) => m_e a -> m_e' s -> m_e'' [a]
sepBy1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e, MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit () m_Unit) => m_e a -> m_e' s -> m_e (NonEmpty a)
skipMany'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' ()
skipMany1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e ()

-- | Combine two alternatives.
eitherP :: Alternative f => f a -> f b -> f Either a b
class MonoFoldable c => Chunk c
osplitAt :: Chunk c => Int -> c -> (c, c)
class DecodingElemsRead s
decodingElemsRead :: DecodingElemsRead s => s -> Word64

-- | Get the total number of bytes read to this point.
elemsRead :: (DecodingState s, DecodingElemsRead s, Monad m) => GetT s i o e m Word64
endOfInput :: (DecodingState s, MonoFoldable (DecodingToken s), Monad m) => GetT s (DecodingToken s) o () m ()

-- | Skip ahead <tt>n</tt> bytes. Fails if fewer than <tt>n</tt> bytes are
--   available.
skip :: (DecodingState s, Chunk (DecodingToken s), Monad m) => Word64 -> GetT s (DecodingToken s) o () m ()

-- | Isolate a decoder to operate with a fixed number of bytes, and fail if
--   fewer bytes were consumed, or if fewer bytes are left in the input.
--   Unlike <a>isolate</a> from binary package, offset from
--   <tt>bytesRead</tt> will NOT be relative to the start of
--   <tt>isolate</tt>.
isolate :: (DecodingState s, Chunk (DecodingToken s), DecodingElemsRead s, Monad m) => Word64 -> GetT s (DecodingToken s) o e m a -> GetT s (DecodingToken s) o (Either (Maybe Word64) e) m a
matchP :: (DecodingState s, Monoid (DecodingToken s), Monad m) => GetT s (DecodingToken s) o e m a -> GetT s (DecodingToken s) o e m (DecodingToken s, a)

-- | Leftover consumed input on error.
tryP :: Monad m => GetT s i o e m a -> GetT s i o e m a
instance (Data.Conduit.Parsers.GetC.DecodingState s, Data.Conduit.Parsers.DecodingElemsRead s) => Data.Conduit.Parsers.DecodingElemsRead (Data.Conduit.Parsers.GetC.Decoding s i)
instance Data.Conduit.Parsers.Chunk Data.ByteString.Internal.ByteString
instance Data.Conduit.Parsers.Chunk Data.Text.Internal.Text


-- | This module provides the <a>PutS</a> functor, and all functions, which
--   could not be defined using <a>PutS</a> public interface only.
module Data.Conduit.Parsers.PutS

-- | Collects encoding process feedback.
class EncodingState s where {
    type family EncodingToken s :: *;
}
encoded :: EncodingState s => EncodingToken s -> s -> s

-- | Trivial encoding state.
data VoidEncodingState
VoidEncodingState :: VoidEncodingState

-- | <a>PutS</a> monad state.
data Encoding s m

-- | Get the total number of bytes wrote to this point.
encodingWrote :: Encoding s m -> s

-- | Get the <a>Producer</a>.
runEncoding :: Encoding s m -> (m ())

-- | Construct <a>PutS</a> initial state.
startEncoding :: Applicative m => s -> Encoding s m

-- | Wrappers for <a>PutM</a> with inner monad <tt>m</tt> and result
--   <tt>a</tt> (usually <tt>()</tt>).
data PutS s m a

-- | Run a <tt>Put</tt> monad, unwrapping all wrappers in a reversible way.
--   <tt><a>putS</a> . runPutS = <a>id</a></tt>
runPutS :: PutS s m a -> Encoding s m -> (a, Encoding s m)

-- | Custom <tt>Put</tt>. <tt>putS . <a>runPutS</a> = <a>id</a></tt>
putS :: (Encoding s m -> (a, Encoding s m)) -> PutS s m a

-- | A <a>ConduitT</a> with wrappers supposed to a binary or text
--   serialization.
type PutM s i o m a = PutS s (ConduitT i o m) a
instance GHC.Base.Monad (Data.Conduit.Parsers.PutS.PutS s m)
instance GHC.Base.Functor (Data.Conduit.Parsers.PutS.PutS s m)
instance Control.Monad.Fix.MonadFix (Data.Conduit.Parsers.PutS.PutS s m)
instance GHC.Base.Applicative (Data.Conduit.Parsers.PutS.PutS s m)
instance (Data.Conduit.Parsers.PutS.EncodingState s, Data.Conduit.Parsers.PutS.EncodingToken s ~ (), GHC.Base.Monad m) => Data.String.IsString (Data.Conduit.Parsers.PutS.PutM s i Data.Text.Internal.Text m ())
instance GHC.Base.Monad m => GHC.Base.Semigroup (Data.Conduit.Parsers.PutS.PutS s m ())
instance (Data.Conduit.Parsers.PutS.EncodingState s, GHC.Base.Monad m) => Data.Conduit.Parsers.PutS.EncodingState (Data.Conduit.Parsers.PutS.Encoding s m)
instance Data.Conduit.Parsers.PutS.EncodingState Data.Conduit.Parsers.PutS.VoidEncodingState


-- | This module provides the <tt>GetC</tt> monad transformer, and all
--   functions, which could not be defined using <tt>GetC</tt> public
--   interface only.
module Data.Conduit.Parsers.Binary
class EncodingBytesWrote s
encodingBytesWrote :: EncodingBytesWrote s => s -> Word64
instance Data.Conduit.Parsers.Binary.EncodingBytesWrote s => Data.Conduit.Parsers.Binary.EncodingBytesWrote (Data.Conduit.Parsers.PutS.Encoding s m)

module Data.Conduit.Parsers.Binary.ByteOffset
newtype ByteOffset
ByteOffset :: Word64 -> ByteOffset
instance GHC.Show.Show Data.Conduit.Parsers.Binary.ByteOffset.ByteOffset
instance Data.Conduit.Parsers.GetC.DecodingState Data.Conduit.Parsers.Binary.ByteOffset.ByteOffset
instance Data.Conduit.Parsers.DecodingElemsRead Data.Conduit.Parsers.Binary.ByteOffset.ByteOffset
instance Data.Conduit.Parsers.PutS.EncodingState Data.Conduit.Parsers.Binary.ByteOffset.ByteOffset
instance Data.Conduit.Parsers.Binary.EncodingBytesWrote Data.Conduit.Parsers.Binary.ByteOffset.ByteOffset


-- | Despite binary's <a>Put</a> is fully-functional construction (unlike
--   <a>Get</a>), we decided to provide this module for symmetry with
--   <a>Get</a>.
module Data.Conduit.Parsers.Binary.Put

-- | A <a>ConduitT</a> with wrappers supposed to a binary or text
--   serialization.
type PutM s i o m a = PutS s (ConduitT i o m) a
class (EncodingState s, EncodingToken s ~ Word64, EncodingBytesWrote s) => DefaultEncodingState s

-- | The shortening of <a>PutM</a> for the most common use case of binary
--   serialization.
type Put = forall s i m. (DefaultEncodingState s, Monad m) => PutM s i ByteString m ()

-- | Run an encoder presented as a <a>Put</a> monad. Returns
--   <a>Producer</a>.
runPut :: PutM ByteOffset i o m () -> ConduitT i o m ()

-- | Get the total number of bytes wrote to this point. Can be used with
--   <a>mfix</a> to result bytes count prediction:
--   
--   <pre>
--   putWithSize :: (DefaultEncodingState s, Monad m) =&gt; PutM s i S.ByteString m () -&gt; PutM s i S.ByteString m ()
--   putWithSize !p = void $ mfix $ \size -&gt; do
--     putWord64le size
--     before &lt;- bytesWrote
--     p
--     after &lt;- bytesWrote
--     return $ after - before
--   </pre>
bytesWrote :: EncodingBytesWrote s => PutM s i o m Word64

-- | Run the given <a>Put</a> encoder from binary package producing the
--   given bytes count and convert result into a <a>Put</a>.
castPut :: (EncodingState s, Monad m) => EncodingToken s -> Put -> PutM s i ByteString m ()

-- | Write a byte.
putWord8 :: (EncodingState s, Num (EncodingToken s), Monad m) => Word8 -> PutM s i ByteString m ()

-- | Write a signed byte.
putInt8 :: (EncodingState s, Num (EncodingToken s), Monad m) => Int8 -> PutM s i ByteString m ()

-- | Write a strict <a>ByteString</a>.
putByteString :: (EncodingState s, Num (EncodingToken s), Monad m) => ByteString -> PutM s i ByteString m ()

-- | Write a lazy <a>ByteString</a>.
putLazyByteString :: (EncodingState s, Num (EncodingToken s), Monad m) => ByteString -> PutM s i ByteString m ()

-- | Write a <a>ShortByteString</a>.
putShortByteString :: (EncodingState s, Num (EncodingToken s), Monad m) => ShortByteString -> PutM s i ByteString m ()

-- | Write a <a>Word16</a> in big endian format.
putWord16be :: (EncodingState s, Num (EncodingToken s), Monad m) => Word16 -> PutM s i ByteString m ()

-- | Write a <a>Word32</a> in big endian format.
putWord32be :: (EncodingState s, Num (EncodingToken s), Monad m) => Word32 -> PutM s i ByteString m ()

-- | Write a <a>Word64</a> in big endian format.
putWord64be :: (EncodingState s, Num (EncodingToken s), Monad m) => Word64 -> PutM s i ByteString m ()

-- | Write an <a>Int16</a> in big endian format.
putInt16be :: (EncodingState s, Num (EncodingToken s), Monad m) => Int16 -> PutM s i ByteString m ()

-- | Write an <a>Int32</a> in big endian format.
putInt32be :: (EncodingState s, Num (EncodingToken s), Monad m) => Int32 -> PutM s i ByteString m ()

-- | Write an <a>Int64</a> in big endian format.
putInt64be :: (EncodingState s, Num (EncodingToken s), Monad m) => Int64 -> PutM s i ByteString m ()

-- | Write a <a>Float</a> in big endian IEEE-754 format.
putFloatbe :: (EncodingState s, Num (EncodingToken s), Monad m) => Float -> PutM s i ByteString m ()

-- | Write a <a>Double</a> in big endian IEEE-754 format.
putDoublebe :: (EncodingState s, Num (EncodingToken s), Monad m) => Double -> PutM s i ByteString m ()

-- | Write a <a>Word16</a> in little endian format.
putWord16le :: (EncodingState s, Num (EncodingToken s), Monad m) => Word16 -> PutM s i ByteString m ()

-- | Write a <a>Word32</a> in little endian format.
putWord32le :: (EncodingState s, Num (EncodingToken s), Monad m) => Word32 -> PutM s i ByteString m ()

-- | Write a <a>Word64</a> in little endian format.
putWord64le :: (EncodingState s, Num (EncodingToken s), Monad m) => Word64 -> PutM s i ByteString m ()

-- | Write an <a>Int16</a> in little endian format.
putInt16le :: (EncodingState s, Num (EncodingToken s), Monad m) => Int16 -> PutM s i ByteString m ()

-- | Write an <a>Int32</a> in little endian format.
putInt32le :: (EncodingState s, Num (EncodingToken s), Monad m) => Int32 -> PutM s i ByteString m ()

-- | Write an <a>Int64</a> in little endian format.
putInt64le :: (EncodingState s, Num (EncodingToken s), Monad m) => Int64 -> PutM s i ByteString m ()

-- | Write a <a>Float</a> in little endian IEEE-754 format.
putFloatle :: (EncodingState s, Num (EncodingToken s), Monad m) => Float -> PutM s i ByteString m ()

-- | Write a <a>Double</a> in little endian IEEE-754 format.
putDoublele :: (EncodingState s, Num (EncodingToken s), Monad m) => Double -> PutM s i ByteString m ()

-- | Write a single native machine word. The word is written in host order,
--   host endian form, for the machine you're on. On a 64 bit machine the
--   <a>Word</a> is an 8 byte value, on a 32 bit machine, 4 bytes. Values
--   written this way are not portable to different endian or word sized
--   machines, without conversion.
putWordhost :: (EncodingState s, Num (EncodingToken s), Monad m) => Word -> PutM s i ByteString m ()

-- | Write a <a>Word16</a> in native host order and host endianness. For
--   portability issues see <a>putWordhost</a>.
putWord16host :: (EncodingState s, Num (EncodingToken s), Monad m) => Word16 -> PutM s i ByteString m ()

-- | Write a <a>Word32</a> in native host order and host endianness. For
--   portability issues see <a>putWordhost</a>.
putWord32host :: (EncodingState s, Num (EncodingToken s), Monad m) => Word32 -> PutM s i ByteString m ()

-- | Write a <a>Word64</a> in native host order On a 32 bit machine we
--   write two host order <a>Word32</a>s, in big endian form. For
--   portability issues see <a>putWordhost</a>.
putWord64host :: (EncodingState s, Num (EncodingToken s), Monad m) => Word64 -> PutM s i ByteString m ()

-- | Write a single native machine word. The word is written in host order,
--   host endian form, for the machine you're on. On a 64 bit machine the
--   <a>Int</a> is an 8 byte value, on a 32 bit machine, 4 bytes. Values
--   written this way are not portable to different endian or word sized
--   machines, without conversion.
putInthost :: (EncodingState s, Num (EncodingToken s), Monad m) => Int -> PutM s i ByteString m ()

-- | Write an <a>Int16</a> in native host order and host endianness. For
--   portability issues see <a>putInthost</a>.
putInt16host :: (EncodingState s, Num (EncodingToken s), Monad m) => Int16 -> PutM s i ByteString m ()

-- | Write an <a>Int32</a> in native host order and host endianness. For
--   portability issues see <a>putInthost</a>.
putInt32host :: (EncodingState s, Num (EncodingToken s), Monad m) => Int32 -> PutM s i ByteString m ()

-- | Write an <a>Int64</a> in native host order On a 32 bit machine we
--   write two host order <a>Int32</a>s, in big endian form. For
--   portability issues see putInthost.
putInt64host :: (EncodingState s, Num (EncodingToken s), Monad m) => Int64 -> PutM s i ByteString m ()

-- | Write a <a>Float</a> in native in IEEE-754 format and host endian.
putFloathost :: (EncodingState s, Num (EncodingToken s), Monad m) => Float -> PutM s i ByteString m ()

-- | Write a <a>Double</a> in native in IEEE-754 format and host endian.
putDoublehost :: (EncodingState s, Num (EncodingToken s), Monad m) => Double -> PutM s i ByteString m ()
instance (Data.Conduit.Parsers.PutS.EncodingState s, Data.Conduit.Parsers.PutS.EncodingToken s ~ GHC.Word.Word64, Data.Conduit.Parsers.Binary.EncodingBytesWrote s) => Data.Conduit.Parsers.Binary.Put.DefaultEncodingState s


-- | At the first look, Data.Binary.Conduit.Get module is very similar with
--   Data.Binary.Get. The main differences between them are the following.
--   While the <a>Get</a> from binary is a very custom monad, the local
--   <a>Get</a> is <a>ConduitT</a>, which leads to easy integration in
--   complicated format parsing. The Data.Binary.Get module does not have a
--   function to create custom <a>Get</a> monad, this module provides
--   <a>getC</a>. Unlike <a>isolate</a> from binary, local <a>isolate</a>
--   does not "cut" bytes counter. While the binary's <a>Get</a> is
--   <tt>MonadFail</tt>, which leads to very ugly errors handling in
--   complicated cases, local <a>Get</a> is <tt>MonadError</tt>.
module Data.Conduit.Parsers.Binary.Get
class (MonadError e m_e, MonadError e' m_e') => MonadMapError e m_e e' m_e' | m_e -> e, m_e' -> e', m_e e' -> m_e', m_e' e -> m_e
mapError :: MonadMapError e m_e e' m_e' => (e -> e') -> m_e a -> m_e' a
(?=>>) :: (MonadMapError e m_e (Either e e') m_Either_e_e', MonadMapError Void m_Void (Either e e') m_Either_e_e', MonadMapError (Either e e') m_Either_e_e' e' m_e') => m_e a -> (e -> m_Void e') -> m_e' a
infixl 1 ?=>>
(?>>) :: (MonadMapError () m_Unit (Maybe e) m_Maybe_e, MonadMapError Void m_Void (Maybe e) m_Maybe_e, MonadMapError (Maybe e) m_Maybe_e e m_e) => m_Unit a -> m_Void e -> m_e a
infixl 1 ?>>
class (DecodingState s, DecodingToken s ~ ByteString, DecodingElemsRead s) => DefaultDecodingState s

-- | A <a>ConduitT</a> with internal transformers supposed to a binary
--   deserialization.
type GetT s i o e m = ConduitT i o (GetC s i e m)

-- | The shortening of <a>GetT</a> for the most common use case of binary
--   deserialization.
type Get e a = forall s o m. (DefaultDecodingState s, Monad m) => GetT s ByteString o e m a

-- | Run a decoder presented as a <a>Get</a> monad. Returns decoder result
--   and consumed bytes count.
runGet :: Monad m => GetT ByteOffset i o e m a -> ConduitT i o m (Either e a)

-- | Get the total number of bytes read to this point.
bytesRead :: (DecodingState s, DecodingElemsRead s, Monad m) => GetT s i o e m Word64

-- | Run the given <a>Get</a> monad from binary package and convert result
--   into <a>Get</a>.
castGet :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => Get a -> GetT s ByteString o String m a

-- | Skip ahead <tt>n</tt> bytes. Fails if fewer than <tt>n</tt> bytes are
--   available.
skip :: (DecodingState s, Chunk (DecodingToken s), Monad m) => Word64 -> GetT s (DecodingToken s) o () m ()

-- | Isolate a decoder to operate with a fixed number of bytes, and fail if
--   fewer bytes were consumed, or if fewer bytes are left in the input.
--   Unlike <a>isolate</a> from binary package, offset from
--   <tt>bytesRead</tt> will NOT be relative to the start of
--   <tt>isolate</tt>.
isolate :: (DecodingState s, Chunk (DecodingToken s), DecodingElemsRead s, Monad m) => Word64 -> GetT s (DecodingToken s) o e m a -> GetT s (DecodingToken s) o (Either (Maybe Word64) e) m a

-- | An efficient get method for strict <a>ByteString</a>s. Fails if fewer
--   than <tt>n</tt> bytes are left in the input. If <tt>n &lt;= 0</tt>
--   then the empty string is returned.
getByteString :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => Int -> GetT s ByteString o () m ByteString

-- | An efficient get method for lazy <a>ByteString</a>s. Fails if fewer
--   than <tt>n</tt> bytes are left in the input. If <tt>n &lt;= 0</tt>
--   then the empty string is returned.
getLazyByteString :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => Int64 -> GetT s ByteString o () m ByteString

-- | Get a lazy <a>ByteString</a> that is terminated with a NUL byte. The
--   returned string does not contain the NUL byte. Fails if it reaches the
--   end of input without finding a NUL.
getLazyByteStringNul :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m ByteString

-- | Get the remaining bytes as a lazy <a>ByteString</a>. Note that this
--   can be an expensive function to use as it forces reading all input and
--   keeping the string in-memory.
getRemainingLazyByteString :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o e m ByteString

-- | Read a <a>Word8</a> from the monad state.
getWord8 :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word8

-- | Read an <a>Int8</a> from the monad state.
getInt8 :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int8

-- | Read a <a>Word16</a> in big endian format.
getWord16be :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word16

-- | Read a <a>Word32</a> in big endian format.
getWord32be :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word32

-- | Read a <a>Word64</a> in big endian format.
getWord64be :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word64

-- | Read a <a>Word16</a> in little endian format.
getWord16le :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word16

-- | Read a <a>Word32</a> in little endian format.
getWord32le :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word32

-- | Read a <a>Word64</a> in little endian format.
getWord64le :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word64

-- | Read a single native machine word. The word is read in host order,
--   host endian form, for the machine you're on. On a 64 bit machine the
--   Word is an 8 byte value, on a 32 bit machine, 4 bytes.
getWordhost :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word

-- | Read a 2 byte <a>Word16</a> in native host order and host endianness.
getWord16host :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word16

-- | Read a 4 byte <a>Word32</a> in native host order and host endianness.
getWord32host :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word32

-- | Read a 8 byte <a>Word64</a> in native host order and host endianness.
getWord64host :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Word64

-- | Read an <a>Int16</a> in big endian format.
getInt16be :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int16

-- | Read an <a>Int32</a> in big endian format.
getInt32be :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int32

-- | Read an <a>Int64</a> in big endian format.
getInt64be :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int64

-- | Read an <a>Int16</a> in little endian format.
getInt16le :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int16

-- | Read an <a>Int32</a> in little endian format.
getInt32le :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int32

-- | Read an <a>Int64</a> in little endian format.
getInt64le :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int64

-- | Read a single native machine word. It works in the same way as
--   <a>getWordhost</a>.
getInthost :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int

-- | Read a 2 byte <a>Int16</a> in native host order and host endianness.
getInt16host :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int16

-- | Read a 4 byte <a>Int32</a> in native host order and host endianness.
getInt32host :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int32

-- | Read a 8 byte <a>Int64</a> in native host order and host endianness.
getInt64host :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Int64

-- | Read a <a>Float</a> in big endian IEEE-754 format.
getFloatbe :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Float

-- | Read a <a>Float</a> in little endian IEEE-754 format.
getFloatle :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Float

-- | Read a <a>Float</a> in IEEE-754 format and host endian.
getFloathost :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Float

-- | Read a <a>Double</a> in big endian IEEE-754 format.
getDoublebe :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Double

-- | Read a <a>Double</a> in little endian IEEE-754 format.
getDoublele :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Double

-- | Read a <a>Double</a> in IEEE-754 format and host endian.
getDoublehost :: (DecodingState s, DecodingToken s ~ ByteString, Monad m) => GetT s ByteString o () m Double
endOfInput :: (DecodingState s, MonoFoldable (DecodingToken s), Monad m) => GetT s (DecodingToken s) o () m ()
instance (Data.Conduit.Parsers.GetC.DecodingState s, Data.Conduit.Parsers.GetC.DecodingToken s ~ Data.ByteString.Internal.ByteString, Data.Conduit.Parsers.DecodingElemsRead s) => Data.Conduit.Parsers.Binary.Get.DefaultDecodingState s


-- | This module provides the <a>GetC</a> monad transformer, and all
--   functions, which could not be defined using <a>GetC</a> public
--   interface only.
module Data.Conduit.Parsers.Text
class DecodingLinesRead s
decodingLinesRead :: DecodingLinesRead s => s -> Word64
class DecodingColumnsRead s
decodingColumnsRead :: DecodingColumnsRead s => s -> Word64
class (DecodingElemsRead s, DecodingLinesRead s, DecodingColumnsRead s) => DecodingTextRead s
instance (Data.Conduit.Parsers.DecodingElemsRead s, Data.Conduit.Parsers.Text.DecodingLinesRead s, Data.Conduit.Parsers.Text.DecodingColumnsRead s) => Data.Conduit.Parsers.Text.DecodingTextRead s
instance (Data.Conduit.Parsers.GetC.DecodingState s, Data.Conduit.Parsers.Text.DecodingColumnsRead s) => Data.Conduit.Parsers.Text.DecodingColumnsRead (Data.Conduit.Parsers.GetC.Decoding s i)
instance (Data.Conduit.Parsers.GetC.DecodingState s, Data.Conduit.Parsers.Text.DecodingLinesRead s) => Data.Conduit.Parsers.Text.DecodingLinesRead (Data.Conduit.Parsers.GetC.Decoding s i)


-- | Text generator. The <a>PutM</a> specialization for text output.
module Data.Conduit.Parsers.Text.Gen

-- | A <a>ConduitT</a> with wrappers supposed to a binary or text
--   serialization.
type PutM s i o m a = PutS s (ConduitT i o m) a

-- | The shortening of <a>PutM</a> for the most common use case of text
--   serialization.
type TextGen = forall s i m. (DefaultTextGenState s, Monad m) => PutM s i Text m ()

-- | Run an encoder presented as a <a>PutM</a> monad. Returns
--   <a>Producer</a>.
runTextGen :: PutM VoidEncodingState i o m () -> ConduitT i o m ()

-- | Output a strict string.
genString :: Text -> TextGen

-- | Output a string.
genLazyString :: Text -> TextGen

-- | Output a showable object.
genShow :: Show a => a -> TextGen

-- | Output a decimal digit.
genDigit :: Integral a => a -> TextGen

-- | Output a hexadecimal digit.
genHexDigit :: Integral a => Bool -> a -> TextGen

-- | Output a byte as a hexadecimal digit pair.
genHexByte :: Bool -> Word8 -> TextGen

-- | Output an enum value.
--   
--   For example, for
--   
--   <pre>
--   data CharKind = CharKindWhitespace | CharKindOrdinar deriving (Eq, Ord, Enum, Bounded, Show)
--   </pre>
--   
--   the following statement is true:
--   
--   <pre>
--   runConduitPure $ runTextGen (genEnum 8 CharKindWhitespace) .| sinkLazy = "Whitespace"
--   </pre>
genEnum :: (Eq a, Ord a, Enum a, Bounded a, Show a) => Int -> a -> TextGen
instance (Data.Conduit.Parsers.PutS.EncodingState s, Data.Conduit.Parsers.PutS.EncodingToken s ~ ()) => Data.Conduit.Parsers.Text.Gen.DefaultTextGenState s

module Data.Conduit.Parsers.Text.TextOffset
data TextOffset
TextOffset :: Word64 -> Word64 -> Word64 -> TextOffset
instance GHC.Show.Show Data.Conduit.Parsers.Text.TextOffset.TextOffset
instance Data.Conduit.Parsers.GetC.DecodingState Data.Conduit.Parsers.Text.TextOffset.TextOffset
instance Data.Conduit.Parsers.DecodingElemsRead Data.Conduit.Parsers.Text.TextOffset.TextOffset
instance Data.Conduit.Parsers.Text.DecodingLinesRead Data.Conduit.Parsers.Text.TextOffset.TextOffset
instance Data.Conduit.Parsers.Text.DecodingColumnsRead Data.Conduit.Parsers.Text.TextOffset.TextOffset

module Data.Conduit.Parsers.Text.Parser
class (MonadError e m_e, MonadError e' m_e') => MonadMapError e m_e e' m_e' | m_e -> e, m_e' -> e', m_e e' -> m_e', m_e' e -> m_e
mapError :: MonadMapError e m_e e' m_e' => (e -> e') -> m_e a -> m_e' a
(?=>>) :: (MonadMapError e m_e (Either e e') m_Either_e_e', MonadMapError Void m_Void (Either e e') m_Either_e_e', MonadMapError (Either e e') m_Either_e_e' e' m_e') => m_e a -> (e -> m_Void e') -> m_e' a
infixl 1 ?=>>
(?>>) :: (MonadMapError () m_Unit (Maybe e) m_Maybe_e, MonadMapError Void m_Void (Maybe e) m_Maybe_e, MonadMapError (Maybe e) m_Maybe_e e m_e) => m_Unit a -> m_Void e -> m_e a
infixl 1 ?>>
class (DecodingState s, DecodingToken s ~ Text, DecodingTextRead s) => DefaultParsingState s

-- | A <a>ConduitT</a> with internal transformers supposed to a binary
--   deserialization.
type GetT s i o e m = ConduitT i o (GetC s i e m)

-- | The shortening of <a>GetT</a> for the most common use case of text
--   deserialization.
type Parser e a = forall s o m. (DefaultParsingState s, Monad m) => GetT s Text o e m a

-- | Run a decoder presented as a <tt>Get</tt> monad. Returns decoder
--   result and consumed bytes count.
runParser :: Monad m => GetT TextOffset i o e m a -> ConduitT i o m (Either e a)

-- | Get the total number of bytes read to this point.
charsRead :: (DecodingState s, DecodingElemsRead s, Monad m) => GetT s i o e m Word64

-- | Get the total number of bytes read to this point.
linesRead :: (DecodingState s, DecodingLinesRead s, Monad m) => GetT s i o e m Word64

-- | Get the total number of bytes read to this point.
columnsRead :: (DecodingState s, DecodingColumnsRead s, Monad m) => GetT s i o e m Word64

-- | Run the given <a>Get</a> monad from binary package and convert result
--   into <tt>Get</tt>.
castParser :: (DecodingState s, DecodingToken s ~ Text, Monad m) => Parser a -> GetT s Text o (NonEmpty String) m a
pCharIs :: Char -> Parser () Char
skipCharIs :: Char -> Parser () ()
pChar :: Parser () Char
pCharIsNot :: Char -> Parser () Char
satisfy :: (Char -> Bool) -> Parser () Char
satisfyWith :: (Char -> a) -> (a -> Bool) -> Parser () a
skip1 :: (Char -> Bool) -> Parser () ()
peekChar :: Parser e (Maybe Char)
peekChar' :: Parser e Char
pDigit :: Integral a => Parser () a
pHexDigit :: Integral a => Parser () a
pHexByte :: Parser () Word8
pLetter :: Parser () Char
pSpace :: Parser () Char

-- | Match any character in a set.
--   
--   <pre>
--   vowel = inClass "aeiou"
--   </pre>
--   
--   Range notation is supported.
--   
--   <pre>
--   halfAlphabet = inClass "a-nA-N"
--   </pre>
--   
--   To add a literal <tt>'-'</tt> to a set, place it at the beginning or
--   end of the string.
inClass :: String -> Char -> Bool

-- | Match any character not in a set.
notInClass :: String -> Char -> Bool
pStringIs :: Text -> Parser () Text
skipStringIs :: Text -> Parser () ()
pAsciiIgnoringCaseIs :: Text -> Parser () Text
skipSpace :: Parser () ()
skipWhile :: (Char -> Bool) -> Parser e ()
scan :: s -> (s -> Char -> Maybe s) -> Parser e Text
runScanner :: s -> (s -> Char -> Maybe s) -> Parser e (Text, s)
pString :: Int -> Parser () Text
pStringWhile :: (Char -> Bool) -> Parser e Text
pStringWhile1 :: (Char -> Bool) -> Parser () Text
pStringTill :: (Char -> Bool) -> Parser e Text
pRemainingString :: Parser e Text
pRemainingLazyString :: Parser e Text
skipEndOfLine :: Parser () ()

-- | A predicate that matches either a carriage return <tt>'\r'</tt> or
--   newline <tt>'\n'</tt> character.
isEndOfLine :: Char -> Bool

-- | A predicate that matches either a space <tt>' '</tt> or horizontal tab
--   <tt>'\t'</tt> character.
isHorizontalSpace :: Char -> Bool
pDecimal :: Integral a => Parser () a
pHexadecimal :: (Integral a, Bits a) => Parser () a
pSignedDecimal :: Integral a => Parser () a
pSignedHexadecimal :: (Integral a, Bits a) => Parser () a
pDouble :: Parser () Double
pRational :: Fractional a => Parser () a
pScientific :: Parser () Scientific

-- | <tt>choice ps</tt> tries to apply the actions in the list <tt>ps</tt>
--   in order, until one of them succeeds. Returns the value of the
--   succeeding action.
choice :: Alternative f => [f a] -> f a

-- | Apply the given action repeatedly, returning every result.
count :: Monad m => Int -> m a -> m [a]
option'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' (Maybe a)
many'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' [a]
many1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e (NonEmpty a)
manyTill'' :: (MonadPlus m_Unit, MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e' b -> m_e [a]
sepBy'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e'' m_e'', MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit () m_Unit) => m_e a -> m_e' s -> m_e'' [a]
sepBy1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e, MonadMapError e' m_e' () m_Unit, MonadMapError () m_Unit () m_Unit) => m_e a -> m_e' s -> m_e (NonEmpty a)
skipMany'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e' m_e') => m_e a -> m_e' ()
skipMany1'' :: (MonadPlus m_Unit, MonadMapError e m_e () m_Unit, MonadMapError () m_Unit e m_e) => m_e a -> m_e ()

-- | Combine two alternatives.
eitherP :: Alternative f => f a -> f b -> f Either a b
matchP :: (DecodingState s, Monoid (DecodingToken s), Monad m) => GetT s (DecodingToken s) o e m a -> GetT s (DecodingToken s) o e m (DecodingToken s, a)

-- | Leftover consumed input on error.
tryP :: Monad m => GetT s i o e m a -> GetT s i o e m a
pEnum :: (Eq a, Ord a, Enum a, Bounded a, Show a) => Int -> Parser () a
endOfInput :: (DecodingState s, MonoFoldable (DecodingToken s), Monad m) => GetT s (DecodingToken s) o () m ()
instance (Data.Conduit.Parsers.GetC.DecodingState s, Data.Conduit.Parsers.GetC.DecodingToken s ~ Data.Text.Internal.Text, Data.Conduit.Parsers.Text.DecodingTextRead s) => Data.Conduit.Parsers.Text.Parser.DefaultParsingState s
