    {-# LANGUAGE FlexibleContexts #-}
    {-# LANGUAGE FlexibleInstances #-}
    {-# LANGUAGE LambdaCase #-}
    {-# LANGUAGE MultiParamTypeClasses #-}
    {-# LANGUAGE RankNTypes #-}
    {-# LANGUAGE Safe #-}
    {-# LANGUAGE ScopedTypeVariables #-}
    {-# LANGUAGE TypeFamilies #-}
    {-# LANGUAGE TypeOperators #-}
    {-# LANGUAGE UndecidableInstances #-}

    -- |
    -- Module      :  Text.Megaparsec.Internal
    -- Copyright   :  © 2015–present Megaparsec contributors
    --                © 2007 Paolo Martini
    --                © 1999–2001 Daan Leijen
    -- License     :  FreeBSD
    --
    -- Maintainer  :  Mark Karpov <markkarpov92@gmail.com>
    -- Stability   :  experimental
    -- Portability :  portable
    --
    -- Internal definitions. Versioning rules do not apply here. Please do not
    -- rely on these unless you really know what you're doing.
    --
    -- @since 6.5.0
    module Text.Megaparsec.Internal
      ( -- * Data types
        Hints (..),
        Reply (..),
        Consumption (..),
        Result (..),
        ParsecT (..),

        -- * Helper functions
        toHints,
        withHints,
        accHints,
        refreshHints,
        runParsecT,
        withParsecT,
      )
    where

    import Control.Applicative
    import Control.Monad
    import Control.Monad.Cont.Class
    import Control.Monad.Error.Class
    import qualified Control.Monad.Fail as Fail
    import Control.Monad.Fix
    import Control.Monad.IO.Class
    import Control.Monad.Reader.Class
    import Control.Monad.State.Class
    import Control.Monad.Trans
    import Data.List.NonEmpty (NonEmpty (..))
    import qualified Data.List.NonEmpty as NE
    import Data.Proxy
    import Data.Semigroup
    import Data.Set (Set)
    import qualified Data.Set as E
    import Data.String (IsString (..))
    import Text.Megaparsec.Class
    import Text.Megaparsec.Error
    import Text.Megaparsec.State
    import Text.Megaparsec.Stream

    ----------------------------------------------------------------------------
    -- Data types

    -- | 'Hints' represent a collection of 'ErrorItem's to be included into
    -- 'ParseError' (when it's a 'TrivialError') as “expected” message items
    -- when a parser fails without consuming input right after successful parser
    -- that produced the hints.
    --
    -- For example, without hints you could get:
    --
    -- >>> parseTest (many (char 'r') <* eof) "ra"
    -- 1:2:
    -- unexpected 'a'
    -- expecting end of input
    --
    -- We're getting better error messages with the help of hints:
    --
    -- >>> parseTest (many (char 'r') <* eof) "ra"
    -- 1:2:
    -- unexpected 'a'
    -- expecting 'r' or end of input
    newtype Hints t = Hints (Set (ErrorItem t))

    instance (Ord t) => Semigroup (Hints t) where
      Hints Set (ErrorItem t)
    xs <> :: Hints t -> Hints t -> Hints t
    <> Hints Set (ErrorItem t)
    ys = Set (ErrorItem t) -> Hints t
    forall t. Set (ErrorItem t) -> Hints t
    Hints (Set (ErrorItem t) -> Hints t) -> Set (ErrorItem t) -> Hints t
    forall a b. (a -> b) -> a -> b
    $ Set (ErrorItem t)
    xs Set (ErrorItem t) -> Set (ErrorItem t) -> Set (ErrorItem t)
    forall a. Semigroup a => a -> a -> a
    <> Set (ErrorItem t)
    ys

    instance (Ord t) => Monoid (Hints t) where
      mempty :: Hints t
    mempty = Set (ErrorItem t) -> Hints t
    forall t. Set (ErrorItem t) -> Hints t
    Hints Set (ErrorItem t)
    forall a. Monoid a => a
    mempty

    -- | All information available after parsing. This includes consumption of
    -- input, success (with the returned value) or failure (with the parse
    -- error), and parser state at the end of parsing.
    --
    -- See also: 'Consumption', 'Result'.
    data Reply e s a = Reply (State s e) Consumption (Result s e a)

    -- | Whether the input has been consumed or not.
    --
    -- See also: 'Result', 'Reply'.
    data Consumption
      = -- | Some part of input stream was consumed
        Consumed
      | -- | No input was consumed
        Virgin

    -- | Whether the parser has failed or not. On success we include the
    -- resulting value, on failure we include a 'ParseError'.
    --
    -- See also: 'Consumption', 'Reply'.
    data Result s e a
      = -- | Parser succeeded
        OK a
      | -- | Parser failed
        Error (ParseError s e)

    -- | @'ParsecT' e s m a@ is a parser with custom data component of error
    -- @e@, stream type @s@, underlying monad @m@ and return type @a@.
    newtype ParsecT e s m a = ParsecT
      { forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ::
          forall b.
          State s e ->
          (a -> State s e -> Hints (Token s) -> m b) -> -- consumed-OK
          (ParseError s e -> State s e -> m b) -> -- consumed-error
          (a -> State s e -> Hints (Token s) -> m b) -> -- empty-OK
          (ParseError s e -> State s e -> m b) -> -- empty-error
          m b
      }

    -- | @since 5.3.0
    instance (Stream s, Semigroup a) => Semigroup (ParsecT e s m a) where
      <> :: ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    (<>) = (a -> a -> a)
    -> ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    forall a b c.
    (a -> b -> c)
    -> ParsecT e s m a -> ParsecT e s m b -> ParsecT e s m c
    forall (f :: * -> *) a b c.
    Applicative f =>
    (a -> b -> c) -> f a -> f b -> f c
    liftA2 a -> a -> a
    forall a. Semigroup a => a -> a -> a
    (<>)
      {-# INLINE (<>) #-}
      sconcat :: NonEmpty (ParsecT e s m a) -> ParsecT e s m a
    sconcat = (NonEmpty a -> a) -> ParsecT e s m (NonEmpty a) -> ParsecT e s m a
    forall a b. (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap NonEmpty a -> a
    forall a. Semigroup a => NonEmpty a -> a
    sconcat (ParsecT e s m (NonEmpty a) -> ParsecT e s m a)
    -> (NonEmpty (ParsecT e s m a) -> ParsecT e s m (NonEmpty a))
    -> NonEmpty (ParsecT e s m a)
    -> ParsecT e s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty (ParsecT e s m a) -> ParsecT e s m (NonEmpty a)
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => NonEmpty (m a) -> m (NonEmpty a)
    sequence
      {-# INLINE sconcat #-}

    -- | @since 5.3.0
    instance (Stream s, Monoid a) => Monoid (ParsecT e s m a) where
      mempty :: ParsecT e s m a
    mempty = a -> ParsecT e s m a
    forall a. a -> ParsecT e s m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure a
    forall a. Monoid a => a
    mempty
      {-# INLINE mempty #-}
      mappend :: ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    mappend = ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    forall a. Semigroup a => a -> a -> a
    (<>)
      {-# INLINE mappend #-}
      mconcat :: [ParsecT e s m a] -> ParsecT e s m a
    mconcat = ([a] -> a) -> ParsecT e s m [a] -> ParsecT e s m a
    forall a b. (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    fmap [a] -> a
    forall a. Monoid a => [a] -> a
    mconcat (ParsecT e s m [a] -> ParsecT e s m a)
    -> ([ParsecT e s m a] -> ParsecT e s m [a])
    -> [ParsecT e s m a]
    -> ParsecT e s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [ParsecT e s m a] -> ParsecT e s m [a]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    forall (m :: * -> *) a. Monad m => [m a] -> m [a]
    sequence
      {-# INLINE mconcat #-}

    -- | @since 6.3.0
    instance
      (a ~ Tokens s, IsString a, Eq a, Stream s, Ord e) =>
      IsString (ParsecT e s m a)
      where
      fromString :: String -> ParsecT e s m a
    fromString String
    s = (Tokens s -> Tokens s -> Bool)
    -> Tokens s -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *).
    MonadParsec e s m =>
    (Tokens s -> Tokens s -> Bool) -> Tokens s -> m (Tokens s)
    tokens a -> a -> Bool
    Tokens s -> Tokens s -> Bool
    forall a. Eq a => a -> a -> Bool
    (==) (String -> a
    forall a. IsString a => String -> a
    fromString String
    s)

    instance Functor (ParsecT e s m) where
      fmap :: forall a b. (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    fmap = (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    forall a b e s (m :: * -> *).
    (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    pMap

    pMap :: (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    pMap :: forall a b e s (m :: * -> *).
    (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    pMap a -> b
    f ParsecT e s m a
    p = (forall b.
     State s e
     -> (b -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (b -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m b
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (b -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (b -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m b)
    -> (forall b.
        State s e
        -> (b -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (b -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m b
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s b -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr b -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s (b -> State s e -> Hints (Token s) -> m b
    cok (b -> State s e -> Hints (Token s) -> m b)
    -> (a -> b) -> a -> State s e -> Hints (Token s) -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    f) ParseError s e -> State s e -> m b
    cerr (b -> State s e -> Hints (Token s) -> m b
    eok (b -> State s e -> Hints (Token s) -> m b)
    -> (a -> b) -> a -> State s e -> Hints (Token s) -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    f) ParseError s e -> State s e -> m b
    eerr
    {-# INLINE pMap #-}

    -- | 'pure' returns a parser that __succeeds__ without consuming input.
    instance (Stream s) => Applicative (ParsecT e s m) where
      pure :: forall a. a -> ParsecT e s m a
    pure = a -> ParsecT e s m a
    forall s a e (m :: * -> *). Stream s => a -> ParsecT e s m a
    pPure
      <*> :: forall a b.
    ParsecT e s m (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    (<*>) = ParsecT e s m (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    forall s e (m :: * -> *) a b.
    Stream s =>
    ParsecT e s m (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    pAp
      ParsecT e s m a
    p1 *> :: forall a b. ParsecT e s m a -> ParsecT e s m b -> ParsecT e s m b
    *> ParsecT e s m b
    p2 = ParsecT e s m a
    p1 ParsecT e s m a -> (a -> ParsecT e s m b) -> ParsecT e s m b
    forall s e (m :: * -> *) a b.
    Stream s =>
    ParsecT e s m a -> (a -> ParsecT e s m b) -> ParsecT e s m b
    `pBind` ParsecT e s m b -> a -> ParsecT e s m b
    forall a b. a -> b -> a
    const ParsecT e s m b
    p2
      ParsecT e s m a
    p1 <* :: forall a b. ParsecT e s m a -> ParsecT e s m b -> ParsecT e s m a
    <* ParsecT e s m b
    p2 = do a
    x1 <- ParsecT e s m a
    p1; ParsecT e s m b -> ParsecT e s m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT e s m b
    p2; a -> ParsecT e s m a
    forall a. a -> ParsecT e s m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x1

    pPure :: (Stream s) => a -> ParsecT e s m a
    pPure :: forall s a e (m :: * -> *). Stream s => a -> ParsecT e s m a
    pPure a
    x = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    _ -> a -> State s e -> Hints (Token s) -> m b
    eok a
    x State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty
    {-# INLINE pPure #-}

    pAp ::
      (Stream s) =>
      ParsecT e s m (a -> b) ->
      ParsecT e s m a ->
      ParsecT e s m b
    pAp :: forall s e (m :: * -> *) a b.
    Stream s =>
    ParsecT e s m (a -> b) -> ParsecT e s m a -> ParsecT e s m b
    pAp ParsecT e s m (a -> b)
    m ParsecT e s m a
    k = (forall b.
     State s e
     -> (b -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (b -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m b
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (b -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (b -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m b)
    -> (forall b.
        State s e
        -> (b -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (b -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m b
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s b -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr b -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let mcok :: (a -> b) -> State s e -> Hints (Token s) -> m b
    mcok a -> b
    x State s e
    s' Hints (Token s)
    hs =
            ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser
              ParsecT e s m a
    k
              State s e
    s'
              (b -> State s e -> Hints (Token s) -> m b
    cok (b -> State s e -> Hints (Token s) -> m b)
    -> (a -> b) -> a -> State s e -> Hints (Token s) -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    x)
              ParseError s e -> State s e -> m b
    cerr
              (Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    forall s a e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    accHints Hints (Token s)
    hs (b -> State s e -> Hints (Token s) -> m b
    cok (b -> State s e -> Hints (Token s) -> m b)
    -> (a -> b) -> a -> State s e -> Hints (Token s) -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    x))
              (Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    forall s e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    withHints Hints (Token s)
    hs ParseError s e -> State s e -> m b
    cerr)
          meok :: (a -> b) -> State s e -> Hints (Token s) -> m b
    meok a -> b
    x State s e
    s' Hints (Token s)
    hs =
            ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser
              ParsecT e s m a
    k
              State s e
    s'
              (b -> State s e -> Hints (Token s) -> m b
    cok (b -> State s e -> Hints (Token s) -> m b)
    -> (a -> b) -> a -> State s e -> Hints (Token s) -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    x)
              ParseError s e -> State s e -> m b
    cerr
              (Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    forall s a e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    accHints Hints (Token s)
    hs (b -> State s e -> Hints (Token s) -> m b
    eok (b -> State s e -> Hints (Token s) -> m b)
    -> (a -> b) -> a -> State s e -> Hints (Token s) -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> b
    x))
              (Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    forall s e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    withHints Hints (Token s)
    hs ParseError s e -> State s e -> m b
    eerr)
       in ParsecT e s m (a -> b)
    -> forall b.
       State s e
       -> ((a -> b) -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> ((a -> b) -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m (a -> b)
    m State s e
    s (a -> b) -> State s e -> Hints (Token s) -> m b
    mcok ParseError s e -> State s e -> m b
    cerr (a -> b) -> State s e -> Hints (Token s) -> m b
    meok ParseError s e -> State s e -> m b
    eerr
    {-# INLINE pAp #-}

    -- | 'empty' is a parser that __fails__ without consuming input.
    instance (Ord e, Stream s) => Alternative (ParsecT e s m) where
      empty :: forall a. ParsecT e s m a
    empty = ParsecT e s m a
    forall a. ParsecT e s m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
      <|> :: forall a. ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    (<|>) = ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    forall a. ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    forall (m :: * -> *) a. MonadPlus m => m a -> m a -> m a
    mplus

    -- | 'return' returns a parser that __succeeds__ without consuming input.
    instance (Stream s) => Monad (ParsecT e s m) where
      return :: forall a. a -> ParsecT e s m a
    return = a -> ParsecT e s m a
    forall a. a -> ParsecT e s m a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure
      >>= :: forall a b.
    ParsecT e s m a -> (a -> ParsecT e s m b) -> ParsecT e s m b
    (>>=) = ParsecT e s m a -> (a -> ParsecT e s m b) -> ParsecT e s m b
    forall s e (m :: * -> *) a b.
    Stream s =>
    ParsecT e s m a -> (a -> ParsecT e s m b) -> ParsecT e s m b
    pBind

    pBind ::
      (Stream s) =>
      ParsecT e s m a ->
      (a -> ParsecT e s m b) ->
      ParsecT e s m b
    pBind :: forall s e (m :: * -> *) a b.
    Stream s =>
    ParsecT e s m a -> (a -> ParsecT e s m b) -> ParsecT e s m b
    pBind ParsecT e s m a
    m a -> ParsecT e s m b
    k = (forall b.
     State s e
     -> (b -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (b -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m b
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (b -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (b -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m b)
    -> (forall b.
        State s e
        -> (b -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (b -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m b
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s b -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr b -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let mcok :: a -> State s e -> Hints (Token s) -> m b
    mcok a
    x State s e
    s' Hints (Token s)
    hs =
            ParsecT e s m b
    -> forall b.
       State s e
       -> (b -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (b -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser
              (a -> ParsecT e s m b
    k a
    x)
              State s e
    s'
              b -> State s e -> Hints (Token s) -> m b
    cok
              ParseError s e -> State s e -> m b
    cerr
              (Hints (Token s)
    -> (b -> State s e -> Hints (Token s) -> m b)
    -> b
    -> State s e
    -> Hints (Token s)
    -> m b
    forall s a e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    accHints Hints (Token s)
    hs b -> State s e -> Hints (Token s) -> m b
    cok)
              (Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    forall s e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    withHints Hints (Token s)
    hs ParseError s e -> State s e -> m b
    cerr)
          meok :: a -> State s e -> Hints (Token s) -> m b
    meok a
    x State s e
    s' Hints (Token s)
    hs =
            ParsecT e s m b
    -> forall b.
       State s e
       -> (b -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (b -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser
              (a -> ParsecT e s m b
    k a
    x)
              State s e
    s'
              b -> State s e -> Hints (Token s) -> m b
    cok
              ParseError s e -> State s e -> m b
    cerr
              (Hints (Token s)
    -> (b -> State s e -> Hints (Token s) -> m b)
    -> b
    -> State s e
    -> Hints (Token s)
    -> m b
    forall s a e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    accHints Hints (Token s)
    hs b -> State s e -> Hints (Token s) -> m b
    eok)
              (Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    forall s e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    withHints Hints (Token s)
    hs ParseError s e -> State s e -> m b
    eerr)
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    m State s e
    s a -> State s e -> Hints (Token s) -> m b
    mcok ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    meok ParseError s e -> State s e -> m b
    eerr
    {-# INLINE pBind #-}

    instance (Stream s) => Fail.MonadFail (ParsecT e s m) where
      fail :: forall a. String -> ParsecT e s m a
    fail = String -> ParsecT e s m a
    forall e s (m :: * -> *) a. String -> ParsecT e s m a
    pFail

    pFail :: String -> ParsecT e s m a
    pFail :: forall e s (m :: * -> *) a. String -> ParsecT e s m a
    pFail String
    msg = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    _ Int
    o PosState s
    _ [ParseError s e]
    _) a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    eerr ->
      let d :: Set (ErrorFancy e)
    d = ErrorFancy e -> Set (ErrorFancy e)
    forall a. a -> Set a
    E.singleton (String -> ErrorFancy e
    forall e. String -> ErrorFancy e
    ErrorFail String
    msg)
       in ParseError s e -> State s e -> m b
    eerr (Int -> Set (ErrorFancy e) -> ParseError s e
    forall s e. Int -> Set (ErrorFancy e) -> ParseError s e
    FancyError Int
    o Set (ErrorFancy e)
    d) State s e
    s
    {-# INLINE pFail #-}

    instance (Stream s, MonadIO m) => MonadIO (ParsecT e s m) where
      liftIO :: forall a. IO a -> ParsecT e s m a
    liftIO = m a -> ParsecT e s m a
    forall (m :: * -> *) a. Monad m => m a -> ParsecT e s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> ParsecT e s m a)
    -> (IO a -> m a) -> IO a -> ParsecT e s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . IO a -> m a
    forall a. IO a -> m a
    forall (m :: * -> *) a. MonadIO m => IO a -> m a
    liftIO

    instance (Stream s, MonadReader r m) => MonadReader r (ParsecT e s m) where
      ask :: ParsecT e s m r
    ask = m r -> ParsecT e s m r
    forall (m :: * -> *) a. Monad m => m a -> ParsecT e s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m r
    forall r (m :: * -> *). MonadReader r m => m r
    ask
      local :: forall a. (r -> r) -> ParsecT e s m a -> ParsecT e s m a
    local r -> r
    f ParsecT e s m a
    p = (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall s (m :: * -> *) e a.
    (Stream s, Monad m) =>
    (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT ((State s e -> m (Reply e s a)) -> ParsecT e s m a)
    -> (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s -> (r -> r) -> m (Reply e s a) -> m (Reply e s a)
    forall a. (r -> r) -> m a -> m a
    forall r (m :: * -> *) a. MonadReader r m => (r -> r) -> m a -> m a
    local r -> r
    f (ParsecT e s m a -> State s e -> m (Reply e s a)
    forall (m :: * -> *) e s a.
    Monad m =>
    ParsecT e s m a -> State s e -> m (Reply e s a)
    runParsecT ParsecT e s m a
    p State s e
    s)

    instance (Stream s, MonadState st m) => MonadState st (ParsecT e s m) where
      get :: ParsecT e s m st
    get = m st -> ParsecT e s m st
    forall (m :: * -> *) a. Monad m => m a -> ParsecT e s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift m st
    forall s (m :: * -> *). MonadState s m => m s
    get
      put :: st -> ParsecT e s m ()
    put = m () -> ParsecT e s m ()
    forall (m :: * -> *) a. Monad m => m a -> ParsecT e s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m () -> ParsecT e s m ())
    -> (st -> m ()) -> st -> ParsecT e s m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . st -> m ()
    forall s (m :: * -> *). MonadState s m => s -> m ()
    put

    instance (Stream s, MonadCont m) => MonadCont (ParsecT e s m) where
      callCC :: forall a b.
    ((a -> ParsecT e s m b) -> ParsecT e s m a) -> ParsecT e s m a
    callCC (a -> ParsecT e s m b) -> ParsecT e s m a
    f = (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall s (m :: * -> *) e a.
    (Stream s, Monad m) =>
    (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT ((State s e -> m (Reply e s a)) -> ParsecT e s m a)
    -> (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s ->
        ((Reply e s a -> m (Reply e s b)) -> m (Reply e s a))
    -> m (Reply e s a)
    forall a b. ((a -> m b) -> m a) -> m a
    forall (m :: * -> *) a b. MonadCont m => ((a -> m b) -> m a) -> m a
    callCC (((Reply e s a -> m (Reply e s b)) -> m (Reply e s a))
     -> m (Reply e s a))
    -> ((Reply e s a -> m (Reply e s b)) -> m (Reply e s a))
    -> m (Reply e s a)
    forall a b. (a -> b) -> a -> b
    $ \Reply e s a -> m (Reply e s b)
    c ->
          ParsecT e s m a -> State s e -> m (Reply e s a)
    forall (m :: * -> *) e s a.
    Monad m =>
    ParsecT e s m a -> State s e -> m (Reply e s a)
    runParsecT ((a -> ParsecT e s m b) -> ParsecT e s m a
    f (\a
    a -> (State s e -> m (Reply e s b)) -> ParsecT e s m b
    forall s (m :: * -> *) e a.
    (Stream s, Monad m) =>
    (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT ((State s e -> m (Reply e s b)) -> ParsecT e s m b)
    -> (State s e -> m (Reply e s b)) -> ParsecT e s m b
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s' -> Reply e s a -> m (Reply e s b)
    c (State s e -> a -> Reply e s a
    forall {s} {e} {a}. State s e -> a -> Reply e s a
    pack State s e
    s' a
    a))) State s e
    s
        where
          pack :: State s e -> a -> Reply e s a
    pack State s e
    s a
    a = State s e -> Consumption -> Result s e a -> Reply e s a
    forall e s a.
    State s e -> Consumption -> Result s e a -> Reply e s a
    Reply State s e
    s Consumption
    Virgin (a -> Result s e a
    forall s e a. a -> Result s e a
    OK a
    a)

    instance (Stream s, MonadError e' m) => MonadError e' (ParsecT e s m) where
      throwError :: forall a. e' -> ParsecT e s m a
    throwError = m a -> ParsecT e s m a
    forall (m :: * -> *) a. Monad m => m a -> ParsecT e s m a
    forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
    (MonadTrans t, Monad m) =>
    m a -> t m a
    lift (m a -> ParsecT e s m a) -> (e' -> m a) -> e' -> ParsecT e s m a
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . e' -> m a
    forall a. e' -> m a
    forall e (m :: * -> *) a. MonadError e m => e -> m a
    throwError
      ParsecT e s m a
    p catchError :: forall a.
    ParsecT e s m a -> (e' -> ParsecT e s m a) -> ParsecT e s m a
    `catchError` e' -> ParsecT e s m a
    h = (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall s (m :: * -> *) e a.
    (Stream s, Monad m) =>
    (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT ((State s e -> m (Reply e s a)) -> ParsecT e s m a)
    -> (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s ->
        ParsecT e s m a -> State s e -> m (Reply e s a)
    forall (m :: * -> *) e s a.
    Monad m =>
    ParsecT e s m a -> State s e -> m (Reply e s a)
    runParsecT ParsecT e s m a
    p State s e
    s m (Reply e s a) -> (e' -> m (Reply e s a)) -> m (Reply e s a)
    forall a. m a -> (e' -> m a) -> m a
    forall e (m :: * -> *) a.
    MonadError e m =>
    m a -> (e -> m a) -> m a
    `catchError` \e'
    e ->
          ParsecT e s m a -> State s e -> m (Reply e s a)
    forall (m :: * -> *) e s a.
    Monad m =>
    ParsecT e s m a -> State s e -> m (Reply e s a)
    runParsecT (e' -> ParsecT e s m a
    h e'
    e) State s e
    s

    mkPT :: (Stream s, Monad m) => (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT :: forall s (m :: * -> *) e a.
    (Stream s, Monad m) =>
    (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT State s e -> m (Reply e s a)
    k = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr -> do
      (Reply State s e
    s' Consumption
    consumption Result s e a
    result) <- State s e -> m (Reply e s a)
    k State s e
    s
      case Consumption
    consumption of
        Consumption
    Consumed ->
          case Result s e a
    result of
            OK a
    x -> a -> State s e -> Hints (Token s) -> m b
    cok a
    x State s e
    s' Hints (Token s)
    forall a. Monoid a => a
    mempty
            Error ParseError s e
    e -> ParseError s e -> State s e -> m b
    cerr ParseError s e
    e State s e
    s'
        Consumption
    Virgin ->
          case Result s e a
    result of
            OK a
    x -> a -> State s e -> Hints (Token s) -> m b
    eok a
    x State s e
    s' Hints (Token s)
    forall a. Monoid a => a
    mempty
            Error ParseError s e
    e -> ParseError s e -> State s e -> m b
    eerr ParseError s e
    e State s e
    s'

    -- | 'mzero' is a parser that __fails__ without consuming input.
    --
    -- __Note__: strictly speaking, this instance is unlawful. The right
    -- identity law does not hold, e.g. in general this is not true:
    --
    -- > v >> mzero = mero
    --
    -- However the following holds:
    --
    -- > try v >> mzero = mzero
    instance (Ord e, Stream s) => MonadPlus (ParsecT e s m) where
      mzero :: forall a. ParsecT e s m a
    mzero = ParsecT e s m a
    forall e s (m :: * -> *) a. ParsecT e s m a
    pZero
      mplus :: forall a. ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    mplus = ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (Ord e, Stream s) =>
    ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    pPlus

    pZero :: ParsecT e s m a
    pZero :: forall e s (m :: * -> *) a. ParsecT e s m a
    pZero = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    _ Int
    o PosState s
    _ [ParseError s e]
    _) a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    eerr ->
      ParseError s e -> State s e -> m b
    eerr (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    forall a. Maybe a
    Nothing Set (ErrorItem (Token s))
    forall a. Set a
    E.empty) State s e
    s
    {-# INLINE pZero #-}

    pPlus ::
      (Ord e, Stream s) =>
      ParsecT e s m a ->
      ParsecT e s m a ->
      ParsecT e s m a
    pPlus :: forall e s (m :: * -> *) a.
    (Ord e, Stream s) =>
    ParsecT e s m a -> ParsecT e s m a -> ParsecT e s m a
    pPlus ParsecT e s m a
    m ParsecT e s m a
    n = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let meerr :: ParseError s e -> State s e -> m b
    meerr ParseError s e
    err State s e
    ms =
            let ncerr :: ParseError s e -> State s e -> m b
    ncerr ParseError s e
    err' State s e
    s' = ParseError s e -> State s e -> m b
    cerr (ParseError s e
    err' ParseError s e -> ParseError s e -> ParseError s e
    forall a. Semigroup a => a -> a -> a
    <> ParseError s e
    err) (State s e -> State s e -> State s e
    forall s e. State s e -> State s e -> State s e
    longestMatch State s e
    ms State s e
    s')
                neok :: a -> State s e -> Hints (Token s) -> m b
    neok a
    x State s e
    s' Hints (Token s)
    hs = a -> State s e -> Hints (Token s) -> m b
    eok a
    x State s e
    s' (Int -> ParseError s e -> Hints (Token s)
    forall s e. Stream s => Int -> ParseError s e -> Hints (Token s)
    toHints (State s e -> Int
    forall s e. State s e -> Int
    stateOffset State s e
    s') ParseError s e
    err Hints (Token s) -> Hints (Token s) -> Hints (Token s)
    forall a. Semigroup a => a -> a -> a
    <> Hints (Token s)
    hs)
                neerr :: ParseError s e -> State s e -> m b
    neerr ParseError s e
    err' State s e
    s' = ParseError s e -> State s e -> m b
    eerr (ParseError s e
    err' ParseError s e -> ParseError s e -> ParseError s e
    forall a. Semigroup a => a -> a -> a
    <> ParseError s e
    err) (State s e -> State s e -> State s e
    forall s e. State s e -> State s e -> State s e
    longestMatch State s e
    ms State s e
    s')
             in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    n State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    ncerr a -> State s e -> Hints (Token s) -> m b
    neok ParseError s e -> State s e -> m b
    neerr
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    m State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    meerr
    {-# INLINE pPlus #-}

    -- | From two states, return the one with the greater number of processed
    -- tokens. If the numbers of processed tokens are equal, prefer the second
    -- state.
    longestMatch :: State s e -> State s e -> State s e
    longestMatch :: forall s e. State s e -> State s e -> State s e
    longestMatch s1 :: State s e
    s1@(State s
    _ Int
    o1 PosState s
    _ [ParseError s e]
    _) s2 :: State s e
    s2@(State s
    _ Int
    o2 PosState s
    _ [ParseError s e]
    _) =
      case Int
    o1 Int -> Int -> Ordering
    forall a. Ord a => a -> a -> Ordering
    `compare` Int
    o2 of
        Ordering
    LT -> State s e
    s2
        Ordering
    EQ -> State s e
    s2
        Ordering
    GT -> State s e
    s1
    {-# INLINE longestMatch #-}

    -- | @since 6.0.0
    instance (Stream s, MonadFix m) => MonadFix (ParsecT e s m) where
      mfix :: forall a. (a -> ParsecT e s m a) -> ParsecT e s m a
    mfix a -> ParsecT e s m a
    f = (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall s (m :: * -> *) e a.
    (Stream s, Monad m) =>
    (State s e -> m (Reply e s a)) -> ParsecT e s m a
    mkPT ((State s e -> m (Reply e s a)) -> ParsecT e s m a)
    -> (State s e -> m (Reply e s a)) -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s -> (Reply e s a -> m (Reply e s a)) -> m (Reply e s a)
    forall a. (a -> m a) -> m a
    forall (m :: * -> *) a. MonadFix m => (a -> m a) -> m a
    mfix ((Reply e s a -> m (Reply e s a)) -> m (Reply e s a))
    -> (Reply e s a -> m (Reply e s a)) -> m (Reply e s a)
    forall a b. (a -> b) -> a -> b
    $ \(~(Reply State s e
    _ Consumption
    _ Result s e a
    result)) -> do
        let a :: a
    a = case Result s e a
    result of
              OK a
    a' -> a
    a'
              Error ParseError s e
    _ -> String -> a
    forall a. HasCallStack => String -> a
    error String
    "mfix ParsecT"
        ParsecT e s m a -> State s e -> m (Reply e s a)
    forall (m :: * -> *) e s a.
    Monad m =>
    ParsecT e s m a -> State s e -> m (Reply e s a)
    runParsecT (a -> ParsecT e s m a
    f a
    a) State s e
    s

    instance (Stream s) => MonadTrans (ParsecT e s) where
      lift :: forall (m :: * -> *) a. Monad m => m a -> ParsecT e s m a
    lift m a
    amb = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    _ ->
        m a
    amb m a -> (a -> m b) -> m b
    forall a b. m a -> (a -> m b) -> m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= \a
    a -> a -> State s e -> Hints (Token s) -> m b
    eok a
    a State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty

    instance (Ord e, Stream s) => MonadParsec e s (ParsecT e s m) where
      parseError :: forall a. ParseError s e -> ParsecT e s m a
    parseError = ParseError s e -> ParsecT e s m a
    forall s e (m :: * -> *) a. ParseError s e -> ParsecT e s m a
    pParseError
      label :: forall a. String -> ParsecT e s m a -> ParsecT e s m a
    label = String -> ParsecT e s m a -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    String -> ParsecT e s m a -> ParsecT e s m a
    pLabel
      try :: forall a. ParsecT e s m a -> ParsecT e s m a
    try = ParsecT e s m a -> ParsecT e s m a
    forall e s (m :: * -> *) a. ParsecT e s m a -> ParsecT e s m a
    pTry
      lookAhead :: forall a. ParsecT e s m a -> ParsecT e s m a
    lookAhead = ParsecT e s m a -> ParsecT e s m a
    forall s e (m :: * -> *) a.
    Stream s =>
    ParsecT e s m a -> ParsecT e s m a
    pLookAhead
      notFollowedBy :: forall a. ParsecT e s m a -> ParsecT e s m ()
    notFollowedBy = ParsecT e s m a -> ParsecT e s m ()
    forall s e (m :: * -> *) a.
    Stream s =>
    ParsecT e s m a -> ParsecT e s m ()
    pNotFollowedBy
      withRecovery :: forall a.
    (ParseError s e -> ParsecT e s m a)
    -> ParsecT e s m a -> ParsecT e s m a
    withRecovery = (ParseError s e -> ParsecT e s m a)
    -> ParsecT e s m a -> ParsecT e s m a
    forall s e (m :: * -> *) a.
    Stream s =>
    (ParseError s e -> ParsecT e s m a)
    -> ParsecT e s m a -> ParsecT e s m a
    pWithRecovery
      observing :: forall a.
    ParsecT e s m a -> ParsecT e s m (Either (ParseError s e) a)
    observing = ParsecT e s m a -> ParsecT e s m (Either (ParseError s e) a)
    forall s e (m :: * -> *) a.
    Stream s =>
    ParsecT e s m a -> ParsecT e s m (Either (ParseError s e) a)
    pObserving
      eof :: ParsecT e s m ()
    eof = ParsecT e s m ()
    forall e s (m :: * -> *). Stream s => ParsecT e s m ()
    pEof
      token :: forall a.
    (Token s -> Maybe a)
    -> Set (ErrorItem (Token s)) -> ParsecT e s m a
    token = (Token s -> Maybe a)
    -> Set (ErrorItem (Token s)) -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    Stream s =>
    (Token s -> Maybe a)
    -> Set (ErrorItem (Token s)) -> ParsecT e s m a
    pToken
      tokens :: (Tokens s -> Tokens s -> Bool)
    -> Tokens s -> ParsecT e s m (Tokens s)
    tokens = (Tokens s -> Tokens s -> Bool)
    -> Tokens s -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *).
    Stream s =>
    (Tokens s -> Tokens s -> Bool)
    -> Tokens s -> ParsecT e s m (Tokens s)
    pTokens
      takeWhileP :: Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    takeWhileP = Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *).
    Stream s =>
    Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    pTakeWhileP
      takeWhile1P :: Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    takeWhile1P = Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *).
    Stream s =>
    Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    pTakeWhile1P
      takeP :: Maybe String -> Int -> ParsecT e s m (Tokens s)
    takeP = Maybe String -> Int -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *).
    Stream s =>
    Maybe String -> Int -> ParsecT e s m (Tokens s)
    pTakeP
      getParserState :: ParsecT e s m (State s e)
    getParserState = ParsecT e s m (State s e)
    forall s e (m :: * -> *). Stream s => ParsecT e s m (State s e)
    pGetParserState
      updateParserState :: (State s e -> State s e) -> ParsecT e s m ()
    updateParserState = (State s e -> State s e) -> ParsecT e s m ()
    forall s e (m :: * -> *).
    Stream s =>
    (State s e -> State s e) -> ParsecT e s m ()
    pUpdateParserState

    pParseError ::
      ParseError s e ->
      ParsecT e s m a
    pParseError :: forall s e (m :: * -> *) a. ParseError s e -> ParsecT e s m a
    pParseError ParseError s e
    e = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    eerr -> ParseError s e -> State s e -> m b
    eerr ParseError s e
    e State s e
    s
    {-# INLINE pParseError #-}

    pLabel :: String -> ParsecT e s m a -> ParsecT e s m a
    pLabel :: forall e s (m :: * -> *) a.
    String -> ParsecT e s m a -> ParsecT e s m a
    pLabel String
    l ParsecT e s m a
    p = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let el :: Maybe (ErrorItem (Token s))
    el = NonEmpty Char -> ErrorItem (Token s)
    forall t. NonEmpty Char -> ErrorItem t
    Label (NonEmpty Char -> ErrorItem (Token s))
    -> Maybe (NonEmpty Char) -> Maybe (ErrorItem (Token s))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> String -> Maybe (NonEmpty Char)
    forall a. [a] -> Maybe (NonEmpty a)
    NE.nonEmpty String
    l
          cok' :: a -> State s e -> Hints (Token s) -> m b
    cok' a
    x State s e
    s' Hints (Token s)
    hs =
            case Maybe (ErrorItem (Token s))
    el of
              Maybe (ErrorItem (Token s))
    Nothing -> a -> State s e -> Hints (Token s) -> m b
    cok a
    x State s e
    s' (Hints (Token s) -> Maybe (ErrorItem (Token s)) -> Hints (Token s)
    forall t. Hints t -> Maybe (ErrorItem t) -> Hints t
    refreshHints Hints (Token s)
    hs Maybe (ErrorItem (Token s))
    forall a. Maybe a
    Nothing)
              Just ErrorItem (Token s)
    _ -> a -> State s e -> Hints (Token s) -> m b
    cok a
    x State s e
    s' Hints (Token s)
    hs
          eok' :: a -> State s e -> Hints (Token s) -> m b
    eok' a
    x State s e
    s' Hints (Token s)
    hs = a -> State s e -> Hints (Token s) -> m b
    eok a
    x State s e
    s' (Hints (Token s) -> Maybe (ErrorItem (Token s)) -> Hints (Token s)
    forall t. Hints t -> Maybe (ErrorItem t) -> Hints t
    refreshHints Hints (Token s)
    hs Maybe (ErrorItem (Token s))
    el)
          eerr' :: ParseError s e -> State s e -> m b
    eerr' ParseError s e
    err = ParseError s e -> State s e -> m b
    eerr (ParseError s e -> State s e -> m b)
    -> ParseError s e -> State s e -> m b
    forall a b. (a -> b) -> a -> b
    $
            case ParseError s e
    err of
              (TrivialError Int
    pos Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    _) ->
                Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    pos Maybe (ErrorItem (Token s))
    us (Set (ErrorItem (Token s))
    -> (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Set (ErrorItem (Token s))
    forall a. Set a
    E.empty ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton Maybe (ErrorItem (Token s))
    el)
              ParseError s e
    _ -> ParseError s e
    err
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok' ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok' ParseError s e -> State s e -> m b
    eerr'
    {-# INLINE pLabel #-}

    pTry :: ParsecT e s m a -> ParsecT e s m a
    pTry :: forall e s (m :: * -> *) a. ParsecT e s m a -> ParsecT e s m a
    pTry ParsecT e s m a
    p = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let eerr' :: ParseError s e -> State s e -> m b
    eerr' ParseError s e
    err State s e
    _ = ParseError s e -> State s e -> m b
    eerr ParseError s e
    err State s e
    s
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    eerr' a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr'
    {-# INLINE pTry #-}

    pLookAhead :: (Stream s) => ParsecT e s m a -> ParsecT e s m a
    pLookAhead :: forall s e (m :: * -> *) a.
    Stream s =>
    ParsecT e s m a -> ParsecT e s m a
    pLookAhead ParsecT e s m a
    p = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let eok' :: a -> State s e -> Hints (Token s) -> m b
    eok' a
    a State s e
    _ Hints (Token s)
    _ = a -> State s e -> Hints (Token s) -> m b
    eok a
    a State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s a -> State s e -> Hints (Token s) -> m b
    eok' ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok' ParseError s e -> State s e -> m b
    eerr
    {-# INLINE pLookAhead #-}

    pNotFollowedBy :: (Stream s) => ParsecT e s m a -> ParsecT e s m ()
    pNotFollowedBy :: forall s e (m :: * -> *) a.
    Stream s =>
    ParsecT e s m a -> ParsecT e s m ()
    pNotFollowedBy ParsecT e s m a
    p = (forall b.
     State s e
     -> (() -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (() -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m ()
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (() -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (() -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m ())
    -> (forall b.
        State s e
        -> (() -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (() -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m ()
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    input Int
    o PosState s
    _ [ParseError s e]
    _) () -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ () -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let what :: ErrorItem (Token s)
    what = ErrorItem (Token s)
    -> ((Token s, s) -> ErrorItem (Token s))
    -> Maybe (Token s, s)
    -> ErrorItem (Token s)
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe ErrorItem (Token s)
    forall t. ErrorItem t
    EndOfInput (NonEmpty (Token s) -> ErrorItem (Token s)
    forall t. NonEmpty t -> ErrorItem t
    Tokens (NonEmpty (Token s) -> ErrorItem (Token s))
    -> ((Token s, s) -> NonEmpty (Token s))
    -> (Token s, s)
    -> ErrorItem (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Token s -> NonEmpty (Token s)
    forall a. a -> NonEmpty a
    nes (Token s -> NonEmpty (Token s))
    -> ((Token s, s) -> Token s) -> (Token s, s) -> NonEmpty (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Token s, s) -> Token s
    forall a b. (a, b) -> a
    fst) (s -> Maybe (Token s, s)
    forall s. Stream s => s -> Maybe (Token s, s)
    take1_ s
    input)
          unexpect :: ErrorItem (Token s) -> ParseError s e
    unexpect ErrorItem (Token s)
    u = Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o (ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ErrorItem (Token s)
    u) Set (ErrorItem (Token s))
    forall a. Set a
    E.empty
          cok' :: a -> State s e -> Hints (Token s) -> m b
    cok' a
    _ State s e
    _ Hints (Token s)
    _ = ParseError s e -> State s e -> m b
    eerr (ErrorItem (Token s) -> ParseError s e
    unexpect ErrorItem (Token s)
    what) State s e
    s
          cerr' :: ParseError s e -> State s e -> m b
    cerr' ParseError s e
    _ State s e
    _ = () -> State s e -> Hints (Token s) -> m b
    eok () State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty
          eok' :: a -> State s e -> Hints (Token s) -> m b
    eok' a
    _ State s e
    _ Hints (Token s)
    _ = ParseError s e -> State s e -> m b
    eerr (ErrorItem (Token s) -> ParseError s e
    unexpect ErrorItem (Token s)
    what) State s e
    s
          eerr' :: ParseError s e -> State s e -> m b
    eerr' ParseError s e
    _ State s e
    _ = () -> State s e -> Hints (Token s) -> m b
    eok () State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok' ParseError s e -> State s e -> m b
    cerr' a -> State s e -> Hints (Token s) -> m b
    eok' ParseError s e -> State s e -> m b
    eerr'
    {-# INLINE pNotFollowedBy #-}

    pWithRecovery ::
      (Stream s) =>
      (ParseError s e -> ParsecT e s m a) ->
      ParsecT e s m a ->
      ParsecT e s m a
    pWithRecovery :: forall s e (m :: * -> *) a.
    Stream s =>
    (ParseError s e -> ParsecT e s m a)
    -> ParsecT e s m a -> ParsecT e s m a
    pWithRecovery ParseError s e -> ParsecT e s m a
    r ParsecT e s m a
    p = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    cerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let mcerr :: ParseError s e -> State s e -> m b
    mcerr ParseError s e
    err State s e
    ms =
            let rcok :: a -> State s e -> Hints (Token s) -> m b
    rcok a
    x State s e
    s' Hints (Token s)
    _ = a -> State s e -> Hints (Token s) -> m b
    cok a
    x State s e
    s' Hints (Token s)
    forall a. Monoid a => a
    mempty
                rcerr :: ParseError s e -> State s e -> m b
    rcerr ParseError s e
    _ State s e
    _ = ParseError s e -> State s e -> m b
    cerr ParseError s e
    err State s e
    ms
                reok :: a -> State s e -> Hints (Token s) -> m b
    reok a
    x State s e
    s' Hints (Token s)
    _ = a -> State s e -> Hints (Token s) -> m b
    eok a
    x State s e
    s' (Int -> ParseError s e -> Hints (Token s)
    forall s e. Stream s => Int -> ParseError s e -> Hints (Token s)
    toHints (State s e -> Int
    forall s e. State s e -> Int
    stateOffset State s e
    s') ParseError s e
    err)
                reerr :: ParseError s e -> State s e -> m b
    reerr ParseError s e
    _ State s e
    _ = ParseError s e -> State s e -> m b
    cerr ParseError s e
    err State s e
    ms
             in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser (ParseError s e -> ParsecT e s m a
    r ParseError s e
    err) State s e
    ms a -> State s e -> Hints (Token s) -> m b
    rcok ParseError s e -> State s e -> m b
    rcerr a -> State s e -> Hints (Token s) -> m b
    reok ParseError s e -> State s e -> m b
    reerr
          meerr :: ParseError s e -> State s e -> m b
    meerr ParseError s e
    err State s e
    ms =
            let rcok :: a -> State s e -> Hints (Token s) -> m b
    rcok a
    x State s e
    s' Hints (Token s)
    _ = a -> State s e -> Hints (Token s) -> m b
    cok a
    x State s e
    s' (Int -> ParseError s e -> Hints (Token s)
    forall s e. Stream s => Int -> ParseError s e -> Hints (Token s)
    toHints (State s e -> Int
    forall s e. State s e -> Int
    stateOffset State s e
    s') ParseError s e
    err)
                rcerr :: ParseError s e -> State s e -> m b
    rcerr ParseError s e
    _ State s e
    _ = ParseError s e -> State s e -> m b
    eerr ParseError s e
    err State s e
    ms
                reok :: a -> State s e -> Hints (Token s) -> m b
    reok a
    x State s e
    s' Hints (Token s)
    _ = a -> State s e -> Hints (Token s) -> m b
    eok a
    x State s e
    s' (Int -> ParseError s e -> Hints (Token s)
    forall s e. Stream s => Int -> ParseError s e -> Hints (Token s)
    toHints (State s e -> Int
    forall s e. State s e -> Int
    stateOffset State s e
    s') ParseError s e
    err)
                reerr :: ParseError s e -> State s e -> m b
    reerr ParseError s e
    _ State s e
    _ = ParseError s e -> State s e -> m b
    eerr ParseError s e
    err State s e
    ms
             in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser (ParseError s e -> ParsecT e s m a
    r ParseError s e
    err) State s e
    ms a -> State s e -> Hints (Token s) -> m b
    rcok ParseError s e -> State s e -> m b
    rcerr a -> State s e -> Hints (Token s) -> m b
    reok ParseError s e -> State s e -> m b
    reerr
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    mcerr a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    meerr
    {-# INLINE pWithRecovery #-}

    pObserving ::
      (Stream s) =>
      ParsecT e s m a ->
      ParsecT e s m (Either (ParseError s e) a)
    pObserving :: forall s e (m :: * -> *) a.
    Stream s =>
    ParsecT e s m a -> ParsecT e s m (Either (ParseError s e) a)
    pObserving ParsecT e s m a
    p = (forall b.
     State s e
     -> (Either (ParseError s e) a
         -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (Either (ParseError s e) a
         -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m (Either (ParseError s e) a)
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (Either (ParseError s e) a
          -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (Either (ParseError s e) a
          -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m (Either (ParseError s e) a))
    -> (forall b.
        State s e
        -> (Either (ParseError s e) a
            -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (Either (ParseError s e) a
            -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m (Either (ParseError s e) a)
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    _ ->
      let cerr' :: ParseError s e -> State s e -> m b
    cerr' ParseError s e
    err State s e
    s' = Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b
    cok (ParseError s e -> Either (ParseError s e) a
    forall a b. a -> Either a b
    Left ParseError s e
    err) State s e
    s' Hints (Token s)
    forall a. Monoid a => a
    mempty
          eerr' :: ParseError s e -> State s e -> m b
    eerr' ParseError s e
    err State s e
    s' = Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b
    eok (ParseError s e -> Either (ParseError s e) a
    forall a b. a -> Either a b
    Left ParseError s e
    err) State s e
    s' (Int -> ParseError s e -> Hints (Token s)
    forall s e. Stream s => Int -> ParseError s e -> Hints (Token s)
    toHints (State s e -> Int
    forall s e. State s e -> Int
    stateOffset State s e
    s') ParseError s e
    err)
       in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s (Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b
    cok (Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b)
    -> (a -> Either (ParseError s e) a)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Either (ParseError s e) a
    forall a b. b -> Either a b
    Right) ParseError s e -> State s e -> m b
    cerr' (Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b
    eok (Either (ParseError s e) a -> State s e -> Hints (Token s) -> m b)
    -> (a -> Either (ParseError s e) a)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . a -> Either (ParseError s e) a
    forall a b. b -> Either a b
    Right) ParseError s e -> State s e -> m b
    eerr'
    {-# INLINE pObserving #-}

    pEof :: forall e s m. (Stream s) => ParsecT e s m ()
    pEof :: forall e s (m :: * -> *). Stream s => ParsecT e s m ()
    pEof = (forall b.
     State s e
     -> (() -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (() -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m ()
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (() -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (() -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m ())
    -> (forall b.
        State s e
        -> (() -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (() -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m ()
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    input Int
    o PosState s
    pst [ParseError s e]
    de) () -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ () -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      case s -> Maybe (Token s, s)
    forall s. Stream s => s -> Maybe (Token s, s)
    take1_ s
    input of
        Maybe (Token s, s)
    Nothing -> () -> State s e -> Hints (Token s) -> m b
    eok () State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty
        Just (Token s
    x, s
    _) ->
          let us :: Maybe (ErrorItem (Token s))
    us = (ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ErrorItem (Token s) -> Maybe (ErrorItem (Token s)))
    -> (Token s -> ErrorItem (Token s))
    -> Token s
    -> Maybe (ErrorItem (Token s))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty (Token s) -> ErrorItem (Token s)
    forall t. NonEmpty t -> ErrorItem t
    Tokens (NonEmpty (Token s) -> ErrorItem (Token s))
    -> (Token s -> NonEmpty (Token s))
    -> Token s
    -> ErrorItem (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Token s -> NonEmpty (Token s)
    forall a. a -> NonEmpty a
    nes) Token s
    x
              ps :: Set (ErrorItem t)
    ps = ErrorItem t -> Set (ErrorItem t)
    forall a. a -> Set a
    E.singleton ErrorItem t
    forall t. ErrorItem t
    EndOfInput
           in ParseError s e -> State s e -> m b
    eerr
                (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    forall {t}. Set (ErrorItem t)
    ps)
                (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input Int
    o PosState s
    pst [ParseError s e]
    de)
    {-# INLINE pEof #-}

    pToken ::
      forall e s m a.
      (Stream s) =>
      (Token s -> Maybe a) ->
      Set (ErrorItem (Token s)) ->
      ParsecT e s m a
    pToken :: forall e s (m :: * -> *) a.
    Stream s =>
    (Token s -> Maybe a)
    -> Set (ErrorItem (Token s)) -> ParsecT e s m a
    pToken Token s -> Maybe a
    test Set (ErrorItem (Token s))
    ps = (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (a -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m a)
    -> (forall b.
        State s e
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (a -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m a
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    input Int
    o PosState s
    pst [ParseError s e]
    de) a -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ a -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    eerr ->
      case s -> Maybe (Token s, s)
    forall s. Stream s => s -> Maybe (Token s, s)
    take1_ s
    input of
        Maybe (Token s, s)
    Nothing ->
          let us :: Maybe (ErrorItem t)
    us = ErrorItem t -> Maybe (ErrorItem t)
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ErrorItem t
    forall t. ErrorItem t
    EndOfInput
           in ParseError s e -> State s e -> m b
    eerr (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    forall {t}. Maybe (ErrorItem t)
    us Set (ErrorItem (Token s))
    ps) State s e
    s
        Just (Token s
    c, s
    cs) ->
          case Token s -> Maybe a
    test Token s
    c of
            Maybe a
    Nothing ->
              let us :: Maybe (ErrorItem (Token s))
    us = (ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    Just (ErrorItem (Token s) -> Maybe (ErrorItem (Token s)))
    -> (Token s -> ErrorItem (Token s))
    -> Token s
    -> Maybe (ErrorItem (Token s))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty (Token s) -> ErrorItem (Token s)
    forall t. NonEmpty t -> ErrorItem t
    Tokens (NonEmpty (Token s) -> ErrorItem (Token s))
    -> (Token s -> NonEmpty (Token s))
    -> Token s
    -> ErrorItem (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Token s -> NonEmpty (Token s)
    forall a. a -> NonEmpty a
    nes) Token s
    c
               in ParseError s e -> State s e -> m b
    eerr
                    (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    ps)
                    (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input Int
    o PosState s
    pst [ParseError s e]
    de)
            Just a
    x ->
              a -> State s e -> Hints (Token s) -> m b
    cok a
    x (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    cs (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    1) PosState s
    pst [ParseError s e]
    de) Hints (Token s)
    forall a. Monoid a => a
    mempty
    {-# INLINE pToken #-}

    pTokens ::
      forall e s m.
      (Stream s) =>
      (Tokens s -> Tokens s -> Bool) ->
      Tokens s ->
      ParsecT e s m (Tokens s)
    pTokens :: forall e s (m :: * -> *).
    Stream s =>
    (Tokens s -> Tokens s -> Bool)
    -> Tokens s -> ParsecT e s m (Tokens s)
    pTokens Tokens s -> Tokens s -> Bool
    f Tokens s
    tts = (forall b.
     State s e
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m (Tokens s))
    -> (forall b.
        State s e
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m (Tokens s)
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    input Int
    o PosState s
    pst [ParseError s e]
    de) Tokens s -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ Tokens s -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    eerr ->
      let pxy :: Proxy s
    pxy = Proxy s
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s
          unexpect :: Int -> ErrorItem (Token s) -> ParseError s e
    unexpect Int
    pos' ErrorItem (Token s)
    u =
            let us :: Maybe (ErrorItem (Token s))
    us = ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ErrorItem (Token s)
    u
                ps :: Set (ErrorItem (Token s))
    ps = (ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> (Tokens s -> ErrorItem (Token s))
    -> Tokens s
    -> Set (ErrorItem (Token s))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty (Token s) -> ErrorItem (Token s)
    forall t. NonEmpty t -> ErrorItem t
    Tokens (NonEmpty (Token s) -> ErrorItem (Token s))
    -> (Tokens s -> NonEmpty (Token s))
    -> Tokens s
    -> ErrorItem (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Token s] -> NonEmpty (Token s)
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([Token s] -> NonEmpty (Token s))
    -> (Tokens s -> [Token s]) -> Tokens s -> NonEmpty (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy s -> Tokens s -> [Token s]
    forall s. Stream s => Proxy s -> Tokens s -> [Token s]
    chunkToTokens Proxy s
    pxy) Tokens s
    tts
             in Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    pos' Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    ps
          len :: Int
    len = Proxy s -> Tokens s -> Int
    forall s. Stream s => Proxy s -> Tokens s -> Int
    chunkLength Proxy s
    pxy Tokens s
    tts
       in case Int -> s -> Maybe (Tokens s, s)
    forall s. Stream s => Int -> s -> Maybe (Tokens s, s)
    takeN_ Int
    len s
    input of
            Maybe (Tokens s, s)
    Nothing ->
              ParseError s e -> State s e -> m b
    eerr (Int -> ErrorItem (Token s) -> ParseError s e
    unexpect Int
    o ErrorItem (Token s)
    forall t. ErrorItem t
    EndOfInput) State s e
    s
            Just (Tokens s
    tts', s
    input') ->
              if Tokens s -> Tokens s -> Bool
    f Tokens s
    tts Tokens s
    tts'
                then
                  let st :: State s e
    st = s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input' (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    len) PosState s
    pst [ParseError s e]
    de
                   in if Proxy s -> Tokens s -> Bool
    forall s. Stream s => Proxy s -> Tokens s -> Bool
    chunkEmpty Proxy s
    pxy Tokens s
    tts
                        then Tokens s -> State s e -> Hints (Token s) -> m b
    eok Tokens s
    tts' State s e
    st Hints (Token s)
    forall a. Monoid a => a
    mempty
                        else Tokens s -> State s e -> Hints (Token s) -> m b
    cok Tokens s
    tts' State s e
    st Hints (Token s)
    forall a. Monoid a => a
    mempty
                else
                  let ps :: ErrorItem (Token s)
    ps = (NonEmpty (Token s) -> ErrorItem (Token s)
    forall t. NonEmpty t -> ErrorItem t
    Tokens (NonEmpty (Token s) -> ErrorItem (Token s))
    -> (Tokens s -> NonEmpty (Token s))
    -> Tokens s
    -> ErrorItem (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [Token s] -> NonEmpty (Token s)
    forall a. HasCallStack => [a] -> NonEmpty a
    NE.fromList ([Token s] -> NonEmpty (Token s))
    -> (Tokens s -> [Token s]) -> Tokens s -> NonEmpty (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Proxy s -> Tokens s -> [Token s]
    forall s. Stream s => Proxy s -> Tokens s -> [Token s]
    chunkToTokens Proxy s
    pxy) Tokens s
    tts'
                   in ParseError s e -> State s e -> m b
    eerr (Int -> ErrorItem (Token s) -> ParseError s e
    unexpect Int
    o ErrorItem (Token s)
    ps) (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input Int
    o PosState s
    pst [ParseError s e]
    de)
    {-# INLINE pTokens #-}

    pTakeWhileP ::
      forall e s m.
      (Stream s) =>
      Maybe String ->
      (Token s -> Bool) ->
      ParsecT e s m (Tokens s)
    pTakeWhileP :: forall e s (m :: * -> *).
    Stream s =>
    Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    pTakeWhileP Maybe String
    ml Token s -> Bool
    f = (forall b.
     State s e
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m (Tokens s))
    -> (forall b.
        State s e
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m (Tokens s)
    forall a b. (a -> b) -> a -> b
    $ \(State s
    input Int
    o PosState s
    pst [ParseError s e]
    de) Tokens s -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ Tokens s -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    _ ->
      let pxy :: Proxy s
    pxy = Proxy s
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s
          (Tokens s
    ts, s
    input') = (Token s -> Bool) -> s -> (Tokens s, s)
    forall s. Stream s => (Token s -> Bool) -> s -> (Tokens s, s)
    takeWhile_ Token s -> Bool
    f s
    input
          len :: Int
    len = Proxy s -> Tokens s -> Int
    forall s. Stream s => Proxy s -> Tokens s -> Int
    chunkLength Proxy s
    pxy Tokens s
    ts
          hs :: Hints (Token s)
    hs =
            case Maybe String
    ml Maybe String
    -> (String -> Maybe (NonEmpty Char)) -> Maybe (NonEmpty Char)
    forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= String -> Maybe (NonEmpty Char)
    forall a. [a] -> Maybe (NonEmpty a)
    NE.nonEmpty of
              Maybe (NonEmpty Char)
    Nothing -> Hints (Token s)
    forall a. Monoid a => a
    mempty
              Just NonEmpty Char
    l -> (Set (ErrorItem (Token s)) -> Hints (Token s)
    forall t. Set (ErrorItem t) -> Hints t
    Hints (Set (ErrorItem (Token s)) -> Hints (Token s))
    -> (NonEmpty Char -> Set (ErrorItem (Token s)))
    -> NonEmpty Char
    -> Hints (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> (NonEmpty Char -> ErrorItem (Token s))
    -> NonEmpty Char
    -> Set (ErrorItem (Token s))
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . NonEmpty Char -> ErrorItem (Token s)
    forall t. NonEmpty Char -> ErrorItem t
    Label) NonEmpty Char
    l
       in if Proxy s -> Tokens s -> Bool
    forall s. Stream s => Proxy s -> Tokens s -> Bool
    chunkEmpty Proxy s
    pxy Tokens s
    ts
            then Tokens s -> State s e -> Hints (Token s) -> m b
    eok Tokens s
    ts (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input' (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    len) PosState s
    pst [ParseError s e]
    de) Hints (Token s)
    hs
            else Tokens s -> State s e -> Hints (Token s) -> m b
    cok Tokens s
    ts (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input' (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    len) PosState s
    pst [ParseError s e]
    de) Hints (Token s)
    hs
    {-# INLINE pTakeWhileP #-}

    pTakeWhile1P ::
      forall e s m.
      (Stream s) =>
      Maybe String ->
      (Token s -> Bool) ->
      ParsecT e s m (Tokens s)
    pTakeWhile1P :: forall e s (m :: * -> *).
    Stream s =>
    Maybe String -> (Token s -> Bool) -> ParsecT e s m (Tokens s)
    pTakeWhile1P Maybe String
    ml Token s -> Bool
    f = (forall b.
     State s e
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m (Tokens s))
    -> (forall b.
        State s e
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m (Tokens s)
    forall a b. (a -> b) -> a -> b
    $ \(State s
    input Int
    o PosState s
    pst [ParseError s e]
    de) Tokens s -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ Tokens s -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    eerr ->
      let pxy :: Proxy s
    pxy = Proxy s
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s
          (Tokens s
    ts, s
    input') = (Token s -> Bool) -> s -> (Tokens s, s)
    forall s. Stream s => (Token s -> Bool) -> s -> (Tokens s, s)
    takeWhile_ Token s -> Bool
    f s
    input
          len :: Int
    len = Proxy s -> Tokens s -> Int
    forall s. Stream s => Proxy s -> Tokens s -> Int
    chunkLength Proxy s
    pxy Tokens s
    ts
          el :: Maybe (ErrorItem (Token s))
    el = NonEmpty Char -> ErrorItem (Token s)
    forall t. NonEmpty Char -> ErrorItem t
    Label (NonEmpty Char -> ErrorItem (Token s))
    -> Maybe (NonEmpty Char) -> Maybe (ErrorItem (Token s))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Maybe String
    ml Maybe String
    -> (String -> Maybe (NonEmpty Char)) -> Maybe (NonEmpty Char)
    forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= String -> Maybe (NonEmpty Char)
    forall a. [a] -> Maybe (NonEmpty a)
    NE.nonEmpty)
          hs :: Hints (Token s)
    hs =
            case Maybe (ErrorItem (Token s))
    el of
              Maybe (ErrorItem (Token s))
    Nothing -> Hints (Token s)
    forall a. Monoid a => a
    mempty
              Just ErrorItem (Token s)
    l -> (Set (ErrorItem (Token s)) -> Hints (Token s)
    forall t. Set (ErrorItem t) -> Hints t
    Hints (Set (ErrorItem (Token s)) -> Hints (Token s))
    -> (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> ErrorItem (Token s)
    -> Hints (Token s)
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton) ErrorItem (Token s)
    l
       in if Proxy s -> Tokens s -> Bool
    forall s. Stream s => Proxy s -> Tokens s -> Bool
    chunkEmpty Proxy s
    pxy Tokens s
    ts
            then
              let us :: Maybe (ErrorItem (Token s))
    us = ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure (ErrorItem (Token s) -> Maybe (ErrorItem (Token s)))
    -> ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a b. (a -> b) -> a -> b
    $
                    case s -> Maybe (Token s, s)
    forall s. Stream s => s -> Maybe (Token s, s)
    take1_ s
    input of
                      Maybe (Token s, s)
    Nothing -> ErrorItem (Token s)
    forall t. ErrorItem t
    EndOfInput
                      Just (Token s
    t, s
    _) -> NonEmpty (Token s) -> ErrorItem (Token s)
    forall t. NonEmpty t -> ErrorItem t
    Tokens (Token s -> NonEmpty (Token s)
    forall a. a -> NonEmpty a
    nes Token s
    t)
                  ps :: Set (ErrorItem (Token s))
    ps = Set (ErrorItem (Token s))
    -> (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Set (ErrorItem (Token s))
    forall a. Set a
    E.empty ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton Maybe (ErrorItem (Token s))
    el
               in ParseError s e -> State s e -> m b
    eerr
                    (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    ps)
                    (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input Int
    o PosState s
    pst [ParseError s e]
    de)
            else Tokens s -> State s e -> Hints (Token s) -> m b
    cok Tokens s
    ts (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input' (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    len) PosState s
    pst [ParseError s e]
    de) Hints (Token s)
    hs
    {-# INLINE pTakeWhile1P #-}

    pTakeP ::
      forall e s m.
      (Stream s) =>
      Maybe String ->
      Int ->
      ParsecT e s m (Tokens s)
    pTakeP :: forall e s (m :: * -> *).
    Stream s =>
    Maybe String -> Int -> ParsecT e s m (Tokens s)
    pTakeP Maybe String
    ml Int
    n' = (forall b.
     State s e
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (Tokens s -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m (Tokens s)
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (Tokens s -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m (Tokens s))
    -> (forall b.
        State s e
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (Tokens s -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m (Tokens s)
    forall a b. (a -> b) -> a -> b
    $ \s :: State s e
    s@(State s
    input Int
    o PosState s
    pst [ParseError s e]
    de) Tokens s -> State s e -> Hints (Token s) -> m b
    cok ParseError s e -> State s e -> m b
    _ Tokens s -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    eerr ->
      let n :: Int
    n = Int -> Int -> Int
    forall a. Ord a => a -> a -> a
    max Int
    0 Int
    n'
          pxy :: Proxy s
    pxy = Proxy s
    forall {k} (t :: k). Proxy t
    Proxy :: Proxy s
          el :: Maybe (ErrorItem (Token s))
    el = NonEmpty Char -> ErrorItem (Token s)
    forall t. NonEmpty Char -> ErrorItem t
    Label (NonEmpty Char -> ErrorItem (Token s))
    -> Maybe (NonEmpty Char) -> Maybe (ErrorItem (Token s))
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> (Maybe String
    ml Maybe String
    -> (String -> Maybe (NonEmpty Char)) -> Maybe (NonEmpty Char)
    forall a b. Maybe a -> (a -> Maybe b) -> Maybe b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= String -> Maybe (NonEmpty Char)
    forall a. [a] -> Maybe (NonEmpty a)
    NE.nonEmpty)
          ps :: Set (ErrorItem (Token s))
    ps = Set (ErrorItem (Token s))
    -> (ErrorItem (Token s) -> Set (ErrorItem (Token s)))
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    forall b a. b -> (a -> b) -> Maybe a -> b
    maybe Set (ErrorItem (Token s))
    forall a. Set a
    E.empty ErrorItem (Token s) -> Set (ErrorItem (Token s))
    forall a. a -> Set a
    E.singleton Maybe (ErrorItem (Token s))
    el
       in case Int -> s -> Maybe (Tokens s, s)
    forall s. Stream s => Int -> s -> Maybe (Tokens s, s)
    takeN_ Int
    n s
    input of
            Maybe (Tokens s, s)
    Nothing ->
              ParseError s e -> State s e -> m b
    eerr (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    o (ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ErrorItem (Token s)
    forall t. ErrorItem t
    EndOfInput) Set (ErrorItem (Token s))
    ps) State s e
    s
            Just (Tokens s
    ts, s
    input') ->
              let len :: Int
    len = Proxy s -> Tokens s -> Int
    forall s. Stream s => Proxy s -> Tokens s -> Int
    chunkLength Proxy s
    pxy Tokens s
    ts
               in if Int
    len Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    /= Int
    n
                    then
                      ParseError s e -> State s e -> m b
    eerr
                        (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    len) (ErrorItem (Token s) -> Maybe (ErrorItem (Token s))
    forall a. a -> Maybe a
    forall (f :: * -> *) a. Applicative f => a -> f a
    pure ErrorItem (Token s)
    forall t. ErrorItem t
    EndOfInput) Set (ErrorItem (Token s))
    ps)
                        (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input Int
    o PosState s
    pst [ParseError s e]
    de)
                    else Tokens s -> State s e -> Hints (Token s) -> m b
    cok Tokens s
    ts (s -> Int -> PosState s -> [ParseError s e] -> State s e
    forall s e. s -> Int -> PosState s -> [ParseError s e] -> State s e
    State s
    input' (Int
    o Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    len) PosState s
    pst [ParseError s e]
    de) Hints (Token s)
    forall a. Monoid a => a
    mempty
    {-# INLINE pTakeP #-}

    pGetParserState :: (Stream s) => ParsecT e s m (State s e)
    pGetParserState :: forall s e (m :: * -> *). Stream s => ParsecT e s m (State s e)
    pGetParserState = (forall b.
     State s e
     -> (State s e -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (State s e -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m (State s e)
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (State s e -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (State s e -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m (State s e))
    -> (forall b.
        State s e
        -> (State s e -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (State s e -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m (State s e)
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s State s e -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ State s e -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    _ -> State s e -> State s e -> Hints (Token s) -> m b
    eok State s e
    s State s e
    s Hints (Token s)
    forall a. Monoid a => a
    mempty
    {-# INLINE pGetParserState #-}

    pUpdateParserState :: (Stream s) => (State s e -> State s e) -> ParsecT e s m ()
    pUpdateParserState :: forall s e (m :: * -> *).
    Stream s =>
    (State s e -> State s e) -> ParsecT e s m ()
    pUpdateParserState State s e -> State s e
    f = (forall b.
     State s e
     -> (() -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (() -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m ()
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e
      -> (() -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> (() -> State s e -> Hints (Token s) -> m b)
      -> (ParseError s e -> State s e -> m b)
      -> m b)
     -> ParsecT e s m ())
    -> (forall b.
        State s e
        -> (() -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> (() -> State s e -> Hints (Token s) -> m b)
        -> (ParseError s e -> State s e -> m b)
        -> m b)
    -> ParsecT e s m ()
    forall a b. (a -> b) -> a -> b
    $ \State s e
    s () -> State s e -> Hints (Token s) -> m b
    _ ParseError s e -> State s e -> m b
    _ () -> State s e -> Hints (Token s) -> m b
    eok ParseError s e -> State s e -> m b
    _ -> () -> State s e -> Hints (Token s) -> m b
    eok () (State s e -> State s e
    f State s e
    s) Hints (Token s)
    forall a. Monoid a => a
    mempty
    {-# INLINE pUpdateParserState #-}

    nes :: a -> NonEmpty a
    nes :: forall a. a -> NonEmpty a
    nes a
    x = a
    x a -> [a] -> NonEmpty a
    forall a. a -> [a] -> NonEmpty a
    :| []
    {-# INLINE nes #-}

    ----------------------------------------------------------------------------
    -- Helper functions

    -- | Convert a 'ParseError' record into 'Hints'.
    toHints ::
      (Stream s) =>
      -- | Current offset in input stream
      Int ->
      -- | Parse error to convert
      ParseError s e ->
      Hints (Token s)
    toHints :: forall s e. Stream s => Int -> ParseError s e -> Hints (Token s)
    toHints Int
    streamPos = \case
      TrivialError Int
    errOffset Maybe (ErrorItem (Token s))
    _ Set (ErrorItem (Token s))
    ps ->
        -- NOTE This is important to check here that the error indeed has
        -- happened at the same position as current position of stream because
        -- there might have been backtracking with 'try' and in that case we
        -- must not convert such a parse error to hints.
        if Int
    streamPos Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    errOffset
          then Set (ErrorItem (Token s)) -> Hints (Token s)
    forall t. Set (ErrorItem t) -> Hints t
    Hints (if Set (ErrorItem (Token s)) -> Bool
    forall a. Set a -> Bool
    E.null Set (ErrorItem (Token s))
    ps then Set (ErrorItem (Token s))
    forall a. Set a
    E.empty else Set (ErrorItem (Token s))
    ps)
          else Hints (Token s)
    forall a. Monoid a => a
    mempty
      FancyError Int
    _ Set (ErrorFancy e)
    _ -> Hints (Token s)
    forall a. Monoid a => a
    mempty
    {-# INLINE toHints #-}

    -- | @'withHints' hs c@ makes “error” continuation @c@ use given hints @hs@.
    --
    -- __Note__ that if resulting continuation gets 'ParseError' that has custom
    -- data in it, hints are ignored.
    withHints ::
      (Stream s) =>
      -- | Hints to use
      Hints (Token s) ->
      -- | Continuation to influence
      (ParseError s e -> State s e -> m b) ->
      -- | First argument of resulting continuation
      ParseError s e ->
      -- | Second argument of resulting continuation
      State s e ->
      m b
    withHints :: forall s e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (ParseError s e -> State s e -> m b)
    -> ParseError s e
    -> State s e
    -> m b
    withHints (Hints Set (ErrorItem (Token s))
    ps') ParseError s e -> State s e -> m b
    c ParseError s e
    e =
      case ParseError s e
    e of
        TrivialError Int
    pos Maybe (ErrorItem (Token s))
    us Set (ErrorItem (Token s))
    ps -> ParseError s e -> State s e -> m b
    c (Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    forall s e.
    Int
    -> Maybe (ErrorItem (Token s))
    -> Set (ErrorItem (Token s))
    -> ParseError s e
    TrivialError Int
    pos Maybe (ErrorItem (Token s))
    us (Set (ErrorItem (Token s))
    -> Set (ErrorItem (Token s)) -> Set (ErrorItem (Token s))
    forall a. Ord a => Set a -> Set a -> Set a
    E.union Set (ErrorItem (Token s))
    ps Set (ErrorItem (Token s))
    ps'))
        ParseError s e
    _ -> ParseError s e -> State s e -> m b
    c ParseError s e
    e
    {-# INLINE withHints #-}

    -- | @'accHints' hs c@ results in “OK” continuation that will add given
    -- hints @hs@ to third argument of original continuation @c@.
    accHints ::
      (Stream s) =>
      -- | 'Hints' to add
      Hints (Token s) ->
      -- | An “OK” continuation to alter
      (a -> State s e -> Hints (Token s) -> m b) ->
      -- | Altered “OK” continuation
      (a -> State s e -> Hints (Token s) -> m b)
    accHints :: forall s a e (m :: * -> *) b.
    Stream s =>
    Hints (Token s)
    -> (a -> State s e -> Hints (Token s) -> m b)
    -> a
    -> State s e
    -> Hints (Token s)
    -> m b
    accHints Hints (Token s)
    hs1 a -> State s e -> Hints (Token s) -> m b
    c a
    x State s e
    s Hints (Token s)
    hs2 = a -> State s e -> Hints (Token s) -> m b
    c a
    x State s e
    s (Hints (Token s)
    hs1 Hints (Token s) -> Hints (Token s) -> Hints (Token s)
    forall a. Semigroup a => a -> a -> a
    <> Hints (Token s)
    hs2)
    {-# INLINE accHints #-}

    -- | Replace the hints with the given 'ErrorItem' (or delete it if 'Nothing'
    -- is given). This is used in the 'label' primitive.
    refreshHints :: Hints t -> Maybe (ErrorItem t) -> Hints t
    refreshHints :: forall t. Hints t -> Maybe (ErrorItem t) -> Hints t
    refreshHints (Hints Set (ErrorItem t)
    _) Maybe (ErrorItem t)
    Nothing = Set (ErrorItem t) -> Hints t
    forall t. Set (ErrorItem t) -> Hints t
    Hints Set (ErrorItem t)
    forall a. Set a
    E.empty
    refreshHints (Hints Set (ErrorItem t)
    hs) (Just ErrorItem t
    m) =
      if Set (ErrorItem t) -> Bool
    forall a. Set a -> Bool
    E.null Set (ErrorItem t)
    hs
        then Set (ErrorItem t) -> Hints t
    forall t. Set (ErrorItem t) -> Hints t
    Hints Set (ErrorItem t)
    hs
        else Set (ErrorItem t) -> Hints t
    forall t. Set (ErrorItem t) -> Hints t
    Hints (ErrorItem t -> Set (ErrorItem t)
    forall a. a -> Set a
    E.singleton ErrorItem t
    m)
    {-# INLINE refreshHints #-}

    -- | Low-level unpacking of the 'ParsecT' type.
    runParsecT ::
      (Monad m) =>
      -- | Parser to run
      ParsecT e s m a ->
      -- | Initial state
      State s e ->
      m (Reply e s a)
    runParsecT :: forall (m :: * -> *) e s a.
    Monad m =>
    ParsecT e s m a -> State s e -> m (Reply e s a)
    runParsecT ParsecT e s m a
    p State s e
    s = ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s a -> State s e -> Hints (Token s) -> m (Reply e s a)
    forall {m :: * -> *} {a} {s} {e} {p}.
    Monad m =>
    a -> State s e -> p -> m (Reply e s a)
    cok ParseError s e -> State s e -> m (Reply e s a)
    forall {m :: * -> *} {s} {e} {a}.
    Monad m =>
    ParseError s e -> State s e -> m (Reply e s a)
    cerr a -> State s e -> Hints (Token s) -> m (Reply e s a)
    forall {m :: * -> *} {a} {s} {e} {p}.
    Monad m =>
    a -> State s e -> p -> m (Reply e s a)
    eok ParseError s e -> State s e -> m (Reply e s a)
    forall {m :: * -> *} {s} {e} {a}.
    Monad m =>
    ParseError s e -> State s e -> m (Reply e s a)
    eerr
      where
        cok :: a -> State s e -> p -> m (Reply e s a)
    cok a
    a State s e
    s' p
    _ = Reply e s a -> m (Reply e s a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Reply e s a -> m (Reply e s a)) -> Reply e s a -> m (Reply e s a)
    forall a b. (a -> b) -> a -> b
    $ State s e -> Consumption -> Result s e a -> Reply e s a
    forall e s a.
    State s e -> Consumption -> Result s e a -> Reply e s a
    Reply State s e
    s' Consumption
    Consumed (a -> Result s e a
    forall s e a. a -> Result s e a
    OK a
    a)
        cerr :: ParseError s e -> State s e -> m (Reply e s a)
    cerr ParseError s e
    err State s e
    s' = Reply e s a -> m (Reply e s a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Reply e s a -> m (Reply e s a)) -> Reply e s a -> m (Reply e s a)
    forall a b. (a -> b) -> a -> b
    $ State s e -> Consumption -> Result s e a -> Reply e s a
    forall e s a.
    State s e -> Consumption -> Result s e a -> Reply e s a
    Reply State s e
    s' Consumption
    Consumed (ParseError s e -> Result s e a
    forall s e a. ParseError s e -> Result s e a
    Error ParseError s e
    err)
        eok :: a -> State s e -> p -> m (Reply e s a)
    eok a
    a State s e
    s' p
    _ = Reply e s a -> m (Reply e s a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Reply e s a -> m (Reply e s a)) -> Reply e s a -> m (Reply e s a)
    forall a b. (a -> b) -> a -> b
    $ State s e -> Consumption -> Result s e a -> Reply e s a
    forall e s a.
    State s e -> Consumption -> Result s e a -> Reply e s a
    Reply State s e
    s' Consumption
    Virgin (a -> Result s e a
    forall s e a. a -> Result s e a
    OK a
    a)
        eerr :: ParseError s e -> State s e -> m (Reply e s a)
    eerr ParseError s e
    err State s e
    s' = Reply e s a -> m (Reply e s a)
    forall a. a -> m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Reply e s a -> m (Reply e s a)) -> Reply e s a -> m (Reply e s a)
    forall a b. (a -> b) -> a -> b
    $ State s e -> Consumption -> Result s e a -> Reply e s a
    forall e s a.
    State s e -> Consumption -> Result s e a -> Reply e s a
    Reply State s e
    s' Consumption
    Virgin (ParseError s e -> Result s e a
    forall s e a. ParseError s e -> Result s e a
    Error ParseError s e
    err)

    -- | Transform any custom errors thrown by the parser using the given
    -- function. Similar in function and purpose to @withExceptT@.
    --
    -- __Note__ that the inner parser will start with an empty collection of
    -- “delayed” 'ParseError's. Any delayed 'ParseError's produced in the inner
    -- parser will be lifted by applying the provided function and added to the
    -- collection of delayed parse errors of the outer parser.
    --
    -- @since 7.0.0
    withParsecT ::
      forall e e' s m a.
      (Monad m, Ord e') =>
      (e -> e') ->
      -- | Inner parser
      ParsecT e s m a ->
      -- | Outer parser
      ParsecT e' s m a
    withParsecT :: forall e e' s (m :: * -> *) a.
    (Monad m, Ord e') =>
    (e -> e') -> ParsecT e s m a -> ParsecT e' s m a
    withParsecT e -> e'
    f ParsecT e s m a
    p =
      (forall b.
     State s e'
     -> (a -> State s e' -> Hints (Token s) -> m b)
     -> (ParseError s e' -> State s e' -> m b)
     -> (a -> State s e' -> Hints (Token s) -> m b)
     -> (ParseError s e' -> State s e' -> m b)
     -> m b)
    -> ParsecT e' s m a
    forall e s (m :: * -> *) a.
    (forall b.
     State s e
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> (a -> State s e -> Hints (Token s) -> m b)
     -> (ParseError s e -> State s e -> m b)
     -> m b)
    -> ParsecT e s m a
    ParsecT ((forall b.
      State s e'
      -> (a -> State s e' -> Hints (Token s) -> m b)
      -> (ParseError s e' -> State s e' -> m b)
      -> (a -> State s e' -> Hints (Token s) -> m b)
      -> (ParseError s e' -> State s e' -> m b)
      -> m b)
     -> ParsecT e' s m a)
    -> (forall b.
        State s e'
        -> (a -> State s e' -> Hints (Token s) -> m b)
        -> (ParseError s e' -> State s e' -> m b)
        -> (a -> State s e' -> Hints (Token s) -> m b)
        -> (ParseError s e' -> State s e' -> m b)
        -> m b)
    -> ParsecT e' s m a
    forall a b. (a -> b) -> a -> b
    $ \State s e'
    s a -> State s e' -> Hints (Token s) -> m b
    cok ParseError s e' -> State s e' -> m b
    cerr a -> State s e' -> Hints (Token s) -> m b
    eok ParseError s e' -> State s e' -> m b
    eerr ->
        let s' :: State s e
    s' =
              State s e'
    s
                { stateParseErrors :: [ParseError s e]
    stateParseErrors = []
                }
            adjustState :: State s e -> State s e'
            adjustState :: State s e -> State s e'
    adjustState State s e
    st =
              State s e
    st
                { stateParseErrors :: [ParseError s e']
    stateParseErrors =
                    ((e -> e') -> ParseError s e -> ParseError s e'
    forall e' e s.
    Ord e' =>
    (e -> e') -> ParseError s e -> ParseError s e'
    mapParseError e -> e'
    f (ParseError s e -> ParseError s e')
    -> [ParseError s e] -> [ParseError s e']
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> State s e -> [ParseError s e]
    forall s e. State s e -> [ParseError s e]
    stateParseErrors State s e
    st)
                      [ParseError s e'] -> [ParseError s e'] -> [ParseError s e']
    forall a. [a] -> [a] -> [a]
    ++ State s e' -> [ParseError s e']
    forall s e. State s e -> [ParseError s e]
    stateParseErrors State s e'
    s
                }
            cok' :: a -> State s e -> Hints (Token s) -> m b
    cok' a
    x State s e
    st Hints (Token s)
    hs = a -> State s e' -> Hints (Token s) -> m b
    cok a
    x (State s e -> State s e'
    adjustState State s e
    st) Hints (Token s)
    hs
            cerr' :: ParseError s e -> State s e -> m b
    cerr' ParseError s e
    e State s e
    st = ParseError s e' -> State s e' -> m b
    cerr ((e -> e') -> ParseError s e -> ParseError s e'
    forall e' e s.
    Ord e' =>
    (e -> e') -> ParseError s e -> ParseError s e'
    mapParseError e -> e'
    f ParseError s e
    e) (State s e -> State s e'
    adjustState State s e
    st)
            eok' :: a -> State s e -> Hints (Token s) -> m b
    eok' a
    x State s e
    st Hints (Token s)
    hs = a -> State s e' -> Hints (Token s) -> m b
    eok a
    x (State s e -> State s e'
    adjustState State s e
    st) Hints (Token s)
    hs
            eerr' :: ParseError s e -> State s e -> m b
    eerr' ParseError s e
    e State s e
    st = ParseError s e' -> State s e' -> m b
    eerr ((e -> e') -> ParseError s e -> ParseError s e'
    forall e' e s.
    Ord e' =>
    (e -> e') -> ParseError s e -> ParseError s e'
    mapParseError e -> e'
    f ParseError s e
    e) (State s e -> State s e'
    adjustState State s e
    st)
         in ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    forall e s (m :: * -> *) a.
    ParsecT e s m a
    -> forall b.
       State s e
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> (a -> State s e -> Hints (Token s) -> m b)
       -> (ParseError s e -> State s e -> m b)
       -> m b
    unParser ParsecT e s m a
    p State s e
    s' a -> State s e -> Hints (Token s) -> m b
    cok' ParseError s e -> State s e -> m b
    cerr' a -> State s e -> Hints (Token s) -> m b
    eok' ParseError s e -> State s e -> m b
    eerr'
    {-# INLINE withParsecT #-}