    -- due to Debug.Trace
    {-# LANGUAGE Trustworthy #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Text.Parsec.Combinator
    -- Copyright   :  (c) Daan Leijen 1999-2001, (c) Paolo Martini 2007
    -- License     :  BSD-style (see the LICENSE file)
    --
    -- Maintainer  :  derek.a.elkins@gmail.com
    -- Stability   :  provisional
    -- Portability :  portable
    --
    -- Commonly used generic combinators.
    --
    -- See also the [parser-combinators](http://hackage.haskell.org/package/parser-combinators)
    -- package for additional (and generalised) combinators.
    --
    -----------------------------------------------------------------------------

    module Text.Parsec.Combinator
        ( choice
        , count
        , between
        , option, optionMaybe, optional
        , skipMany1
        , many1
        , sepBy, sepBy1
        , endBy, endBy1
        , sepEndBy, sepEndBy1
        , chainl, chainl1
        , chainr, chainr1
        , eof, notFollowedBy
        -- tricky combinators
        , manyTill, lookAhead, anyToken
        -- * Debugging
        --
        -- | As a more comprehensive alternative for debugging Parsec parsers,
        -- there's also the [parsec-free](http://hackage.haskell.org/package/parsec-free)
        -- package.
        --
        , parserTrace, parserTraced
        ) where

    import Control.Monad
    import Text.Parsec.Prim
    import Debug.Trace (trace)

    -- | @choice ps@ tries to apply the parsers in the list @ps@ in order,
    -- until one of them succeeds. Returns the value of the succeeding
    -- parser.

    choice :: (Stream s m t) => [ParsecT s u m a] -> ParsecT s u m a
    {-# INLINABLE choice #-}
    choice :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    [ParsecT s u m a] -> ParsecT s u m a
    choice [ParsecT s u m a]
    ps           = (ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a)
    -> ParsecT s u m a -> [ParsecT s u m a] -> ParsecT s u m a
    forall (t :: * -> *) a b.
    Foldable t =>
    (a -> b -> b) -> b -> t a -> b
    foldr ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    (<|>) ParsecT s u m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero [ParsecT s u m a]
    ps

    -- | @option x p@ tries to apply parser @p@. If @p@ fails without
    -- consuming input, it returns the value @x@, otherwise the value
    -- returned by @p@.
    --
    -- >  priority  = option 0 (do{ d <- digit
    -- >                          ; return (digitToInt d)
    -- >                          })

    option :: (Stream s m t) => a -> ParsecT s u m a -> ParsecT s u m a
    {-# INLINABLE option #-}
    option :: forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option a
    x ParsecT s u m a
    p          = ParsecT s u m a
    p ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    -- | @optionMaybe p@ tries to apply parser @p@.  If @p@ fails without
    -- consuming input, it return 'Nothing', otherwise it returns
    -- 'Just' the value returned by @p@.

    optionMaybe :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m (Maybe a)
    {-# INLINABLE optionMaybe #-}
    optionMaybe :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (Maybe a)
    optionMaybe ParsecT s u m a
    p       = Maybe a -> ParsecT s u m (Maybe a) -> ParsecT s u m (Maybe a)
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option Maybe a
    forall a. Maybe a
    Nothing ((a -> Maybe a) -> ParsecT s u m a -> ParsecT s u m (Maybe a)
    forall (m :: * -> *) a1 r. Monad m => (a1 -> r) -> m a1 -> m r
    liftM a -> Maybe a
    forall a. a -> Maybe a
    Just ParsecT s u m a
    p)

    -- | @optional p@ tries to apply parser @p@.  It will parse @p@ or nothing.
    -- It only fails if @p@ fails after consuming input. It discards the result
    -- of @p@.

    optional :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m ()
    {-# INLINABLE optional #-}
    optional :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    optional ParsecT s u m a
    p          = do{ a
    _ <- ParsecT s u m a
    p; () -> ParsecT s u m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()} ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> () -> ParsecT s u m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()

    -- | @between open close p@ parses @open@, followed by @p@ and @close@.
    -- Returns the value returned by @p@.
    --
    -- >  braces  = between (symbol "{") (symbol "}")

    between :: (Stream s m t) => ParsecT s u m open -> ParsecT s u m close
                -> ParsecT s u m a -> ParsecT s u m a
    {-# INLINABLE between #-}
    between :: forall s (m :: * -> *) t u open close a.
    Stream s m t =>
    ParsecT s u m open
    -> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
    between ParsecT s u m open
    open ParsecT s u m close
    close ParsecT s u m a
    p
                        = do{ open
    _ <- ParsecT s u m open
    open; a
    x <- ParsecT s u m a
    p; close
    _ <- ParsecT s u m close
    close; a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x }

    -- | @skipMany1 p@ applies the parser @p@ /one/ or more times, skipping
    -- its result.

    skipMany1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m ()
    {-# INLINABLE skipMany1 #-}
    skipMany1 :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m ()
    skipMany1 ParsecT s u m a
    p         = do{ a
    _ <- ParsecT s u m a
    p; ParsecT s u m a -> ParsecT s u m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT s u m a
    p }
    {-
    skipMany p          = scan
                        where
                          scan  = do{ p; scan } <|> return ()
    -}

    -- | @many1 p@ applies the parser @p@ /one/ or more times. Returns a
    -- list of the returned values of @p@.
    --
    -- >  word  = many1 letter

    many1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m [a]
    {-# INLINABLE many1 #-}
    many1 :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT s u m a
    p             = do{ a
    x <- ParsecT s u m a
    p; [a]
    xs <- ParsecT s u m a -> ParsecT s u m [a]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many ParsecT s u m a
    p; [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    xs) }
    {-
    many p              = scan id
                        where
                          scan f    = do{ x <- p
                                        ; scan (\tail -> f (x:tail))
                                        }
                                    <|> return (f [])
    -}

    -- | @sepBy p sep@ parses /zero/ or more occurrences of @p@, separated
    -- by @sep@. Returns a list of values returned by @p@.
    --
    -- >  commaSep p  = p `sepBy` (symbol ",")

    sepBy :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    {-# INLINABLE sepBy #-}
    sepBy :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepBy ParsecT s u m a
    p ParsecT s u m sep
    sep         = ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepBy1 ParsecT s u m a
    p ParsecT s u m sep
    sep ParsecT s u m [a] -> ParsecT s u m [a] -> ParsecT s u m [a]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return []

    -- | @sepBy1 p sep@ parses /one/ or more occurrences of @p@, separated
    -- by @sep@. Returns a list of values returned by @p@.

    sepBy1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    {-# INLINABLE sepBy1 #-}
    sepBy1 :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepBy1 ParsecT s u m a
    p ParsecT s u m sep
    sep        = do{ a
    x <- ParsecT s u m a
    p
                            ; [a]
    xs <- ParsecT s u m a -> ParsecT s u m [a]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (ParsecT s u m sep
    sep ParsecT s u m sep -> ParsecT s u m a -> ParsecT s u m a
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s u m a
    p)
                            ; [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    xs)
                            }

    -- | @sepEndBy1 p sep@ parses /one/ or more occurrences of @p@,
    -- separated and optionally ended by @sep@. Returns a list of values
    -- returned by @p@.

    sepEndBy1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    {-# INLINABLE sepEndBy1 #-}
    sepEndBy1 :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepEndBy1 ParsecT s u m a
    p ParsecT s u m sep
    sep     = do{ a
    x <- ParsecT s u m a
    p
                            ; do{ sep
    _ <- ParsecT s u m sep
    sep
                                ; [a]
    xs <- ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepEndBy ParsecT s u m a
    p ParsecT s u m sep
    sep
                                ; [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    xs)
                                }
                              ParsecT s u m [a] -> ParsecT s u m [a] -> ParsecT s u m [a]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [a
    x]
                            }

    -- | @sepEndBy p sep@ parses /zero/ or more occurrences of @p@,
    -- separated and optionally ended by @sep@, ie. haskell style
    -- statements. Returns a list of values returned by @p@.
    --
    -- >  haskellStatements  = haskellStatement `sepEndBy` semi

    sepEndBy :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    {-# INLINABLE sepEndBy #-}
    sepEndBy :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepEndBy ParsecT s u m a
    p ParsecT s u m sep
    sep      = ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    sepEndBy1 ParsecT s u m a
    p ParsecT s u m sep
    sep ParsecT s u m [a] -> ParsecT s u m [a] -> ParsecT s u m [a]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return []

    -- | @endBy1 p sep@ parses /one/ or more occurrences of @p@, separated
    -- and ended by @sep@. Returns a list of values returned by @p@.

    endBy1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    {-# INLINABLE endBy1 #-}
    endBy1 :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    endBy1 ParsecT s u m a
    p ParsecT s u m sep
    sep        = ParsecT s u m a -> ParsecT s u m [a]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (do{ a
    x <- ParsecT s u m a
    p; sep
    _ <- ParsecT s u m sep
    sep; a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x })

    -- | @endBy p sep@ parses /zero/ or more occurrences of @p@, separated
    -- and ended by @sep@. Returns a list of values returned by @p@.
    --
    -- >   cStatements  = cStatement `endBy` semi

    endBy :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    {-# INLINABLE endBy #-}
    endBy :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    endBy ParsecT s u m a
    p ParsecT s u m sep
    sep         = ParsecT s u m a -> ParsecT s u m [a]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m [a]
    many (do{ a
    x <- ParsecT s u m a
    p; sep
    _ <- ParsecT s u m sep
    sep; a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x })

    -- | @count n p@ parses @n@ occurrences of @p@. If @n@ is smaller or
    -- equal to zero, the parser equals to @return []@. Returns a list of
    -- @n@ values returned by @p@.

    count :: (Stream s m t) => Int -> ParsecT s u m a -> ParsecT s u m [a]
    {-# INLINABLE count #-}
    count :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    Int -> ParsecT s u m a -> ParsecT s u m [a]
    count Int
    n ParsecT s u m a
    p           | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    <= Int
    0    = [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return []
                        | Bool
    otherwise = [ParsecT s u m a] -> ParsecT s u m [a]
    forall (t :: * -> *) (m :: * -> *) a.
    (Traversable t, Monad m) =>
    t (m a) -> m (t a)
    sequence (Int -> ParsecT s u m a -> [ParsecT s u m a]
    forall a. Int -> a -> [a]
    replicate Int
    n ParsecT s u m a
    p)

    -- | @chainr p op x@ parses /zero/ or more occurrences of @p@,
    -- separated by @op@ Returns a value obtained by a /right/ associative
    -- application of all functions returned by @op@ to the values returned
    -- by @p@. If there are no occurrences of @p@, the value @x@ is
    -- returned.

    chainr :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
    {-# INLINABLE chainr #-}
    chainr :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a
    -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
    chainr ParsecT s u m a
    p ParsecT s u m (a -> a -> a)
    op a
    x       = ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    chainr1 ParsecT s u m a
    p ParsecT s u m (a -> a -> a)
    op ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    -- | @chainl p op x@ parses /zero/ or more occurrences of @p@,
    -- separated by @op@. Returns a value obtained by a /left/ associative
    -- application of all functions returned by @op@ to the values returned
    -- by @p@. If there are zero occurrences of @p@, the value @x@ is
    -- returned.

    chainl :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
    {-# INLINABLE chainl #-}
    chainl :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a
    -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
    chainl ParsecT s u m a
    p ParsecT s u m (a -> a -> a)
    op a
    x       = ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    chainl1 ParsecT s u m a
    p ParsecT s u m (a -> a -> a)
    op ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    -- | @chainl1 p op@ parses /one/ or more occurrences of @p@,
    -- separated by @op@ Returns a value obtained by a /left/ associative
    -- application of all functions returned by @op@ to the values returned
    -- by @p@. This parser can for example be used to eliminate left
    -- recursion which typically occurs in expression grammars.
    --
    -- >  expr    = term   `chainl1` addop
    -- >  term    = factor `chainl1` mulop
    -- >  factor  = parens expr <|> integer
    -- >
    -- >  mulop   =   do{ symbol "*"; return (*)   }
    -- >          <|> do{ symbol "/"; return (div) }
    -- >
    -- >  addop   =   do{ symbol "+"; return (+) }
    -- >          <|> do{ symbol "-"; return (-) }

    chainl1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    {-# INLINABLE chainl1 #-}
    chainl1 :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    chainl1 ParsecT s u m a
    p ParsecT s u m (a -> a -> a)
    op        = do{ a
    x <- ParsecT s u m a
    p; a -> ParsecT s u m a
    rest a
    x }
                        where
                          rest :: a -> ParsecT s u m a
    rest a
    x    = do{ a -> a -> a
    f <- ParsecT s u m (a -> a -> a)
    op
                                        ; a
    y <- ParsecT s u m a
    p
                                        ; a -> ParsecT s u m a
    rest (a -> a -> a
    f a
    x a
    y)
                                        }
                                    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    -- | @chainr1 p op x@ parses /one/ or more occurrences of |p|,
    -- separated by @op@ Returns a value obtained by a /right/ associative
    -- application of all functions returned by @op@ to the values returned
    -- by @p@.

    chainr1 :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    {-# INLINABLE chainr1 #-}
    chainr1 :: forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
    chainr1 ParsecT s u m a
    p ParsecT s u m (a -> a -> a)
    op        = ParsecT s u m a
    scan
                        where
                          scan :: ParsecT s u m a
    scan      = do{ a
    x <- ParsecT s u m a
    p; a -> ParsecT s u m a
    rest a
    x }

                          rest :: a -> ParsecT s u m a
    rest a
    x    = do{ a -> a -> a
    f <- ParsecT s u m (a -> a -> a)
    op
                                        ; a
    y <- ParsecT s u m a
    scan
                                        ; a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a -> a -> a
    f a
    x a
    y)
                                        }
                                    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> a -> ParsecT s u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return a
    x

    -----------------------------------------------------------
    -- Tricky combinators
    -----------------------------------------------------------
    -- | The parser @anyToken@ accepts any kind of token. It is for example
    -- used to implement 'eof'. Returns the accepted token.

    anyToken :: (Stream s m t, Show t) => ParsecT s u m t
    {-# INLINABLE anyToken #-}
    anyToken :: forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m t
    anyToken            = (t -> String)
    -> (SourcePos -> t -> s -> SourcePos)
    -> (t -> Maybe t)
    -> ParsecT s u m t
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    (t -> String)
    -> (SourcePos -> t -> s -> SourcePos)
    -> (t -> Maybe a)
    -> ParsecT s u m a
    tokenPrim t -> String
    forall a. Show a => a -> String
    show (\SourcePos
    pos t
    _tok s
    _toks -> SourcePos
    pos) t -> Maybe t
    forall a. a -> Maybe a
    Just

    -- | This parser only succeeds at the end of the input. This is not a
    -- primitive parser but it is defined using 'notFollowedBy'.
    --
    -- >  eof  = notFollowedBy anyToken <?> "end of input"

    eof :: (Stream s m t, Show t) => ParsecT s u m ()
    {-# INLINABLE eof #-}
    eof :: forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof                 = ParsecT s u m t -> ParsecT s u m ()
    forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT s u m t
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m t
    anyToken ParsecT s u m () -> String -> ParsecT s u m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> String -> ParsecT s u m a
    <?> String
    "end of input"

    -- | @notFollowedBy p@ only succeeds when parser @p@ fails. This parser
    -- does not consume any input. This parser can be used to implement the
    -- \'longest match\' rule. For example, when recognizing keywords (for
    -- example @let@), we want to make sure that a keyword is not followed
    -- by a legal identifier character, in which case the keyword is
    -- actually an identifier (for example @lets@). We can program this
    -- behaviour as follows:
    --
    -- >  keywordLet  = try (do{ string "let"
    -- >                       ; notFollowedBy alphaNum
    -- >                       })
    --
    -- __NOTE__: Currently, 'notFollowedBy' exhibits surprising behaviour
    -- when applied to a parser @p@ that doesn't consume any input;
    -- specifically
    --
    --  - @'notFollowedBy' . 'notFollowedBy'@ is /not/ equivalent to 'lookAhead', and
    --
    --  - @'notFollowedBy' 'eof'@ /never/ fails.
    --
    -- See [haskell/parsec#8](https://github.com/haskell/parsec/issues/8)
    -- for more details.

    notFollowedBy :: (Stream s m t, Show a) => ParsecT s u m a -> ParsecT s u m ()
    {-# INLINABLE notFollowedBy #-}
    notFollowedBy :: forall s (m :: * -> *) t a u.
    (Stream s m t, Show a) =>
    ParsecT s u m a -> ParsecT s u m ()
    notFollowedBy ParsecT s u m a
    p     = ParsecT s u m () -> ParsecT s u m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (do{ a
    c <- ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try ParsecT s u m a
    p; String -> ParsecT s u m ()
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    String -> ParsecT s u m a
    unexpected (a -> String
    forall a. Show a => a -> String
    show a
    c) }
                               ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> () -> ParsecT s u m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
                              )

    -- | @manyTill p end@ applies parser @p@ /zero/ or more times until
    -- parser @end@ succeeds. Returns the list of values returned by @p@.
    -- This parser can be used to scan comments:
    --
    -- >  simpleComment   = do{ string "<!--"
    -- >                      ; manyTill anyChar (try (string "-->"))
    -- >                      }
    --
    --    Note the overlapping parsers @anyChar@ and @string \"-->\"@, and
    --    therefore the use of the 'try' combinator.

    manyTill :: (Stream s m t) => ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
    {-# INLINABLE manyTill #-}
    manyTill :: forall s (m :: * -> *) t u a sep.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
    manyTill ParsecT s u m a
    p ParsecT s u m end
    end      = ParsecT s u m [a]
    scan
                        where
                          scan :: ParsecT s u m [a]
    scan  = do{ end
    _ <- ParsecT s u m end
    end; [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return [] }
                                ParsecT s u m [a] -> ParsecT s u m [a] -> ParsecT s u m [a]
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|>
                                  do{ a
    x <- ParsecT s u m a
    p; [a]
    xs <- ParsecT s u m [a]
    scan; [a] -> ParsecT s u m [a]
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    xa -> [a] -> [a]
    forall a. a -> [a] -> [a]
    :[a]
    xs) }

    -- | @parserTrace label@ is an impure function, implemented with "Debug.Trace" that
    -- prints to the console the remaining parser state at the time it is invoked.
    -- It is intended to be used for debugging parsers by inspecting their intermediate states.
    --
    -- > *> parseTest (oneOf "aeiou"  >> parserTrace "label") "atest"
    -- > label: "test"
    -- > ...
    --
    -- @since 3.1.12.0
    parserTrace :: (Show t, Stream s m t) => String -> ParsecT s u m ()
    {-# INLINABLE parserTrace #-}
    parserTrace :: forall t s (m :: * -> *) u.
    (Show t, Stream s m t) =>
    String -> ParsecT s u m ()
    parserTrace String
    s = ParsecT s u m ()
    forall {u} {a}. ParsecT s u m a
    pt ParsecT s u m () -> ParsecT s u m () -> ParsecT s u m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> () -> ParsecT s u m ()
    forall (m :: * -> *) a. Monad m => a -> m a
    return ()
        where
            pt :: ParsecT s u m a
    pt = ParsecT s u m a -> ParsecT s u m a
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m a -> ParsecT s u m a)
    -> ParsecT s u m a -> ParsecT s u m a
    forall a b. (a -> b) -> a -> b
    $ do
               [t]
    x <- ParsecT s u m [t] -> ParsecT s u m [t]
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m [t] -> ParsecT s u m [t])
    -> ParsecT s u m [t] -> ParsecT s u m [t]
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m t -> ParsecT s u m [t]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 ParsecT s u m t
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m t
    anyToken
               String -> ParsecT s u m () -> ParsecT s u m ()
    forall a. String -> a -> a
    trace (String
    sString -> String -> String
    forall a. [a] -> [a] -> [a]
    ++String
    ": " String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ [t] -> String
    forall a. Show a => a -> String
    show [t]
    x) (ParsecT s u m () -> ParsecT s u m ())
    -> ParsecT s u m () -> ParsecT s u m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m () -> ParsecT s u m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT s u m () -> ParsecT s u m ())
    -> ParsecT s u m () -> ParsecT s u m ()
    forall a b. (a -> b) -> a -> b
    $ ParsecT s u m ()
    forall s (m :: * -> *) t u.
    (Stream s m t, Show t) =>
    ParsecT s u m ()
    eof
               String -> ParsecT s u m a
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail ([t] -> String
    forall a. Show a => a -> String
    show [t]
    x)

    -- | @parserTraced label p@ is an impure function, implemented with "Debug.Trace" that
    -- prints to the console the remaining parser state at the time it is invoked.
    -- It then continues to apply parser @p@, and if @p@ fails will indicate that
    -- the label has been backtracked.
    -- It is intended to be used for debugging parsers by inspecting their intermediate states.
    --
    -- > *>  parseTest (oneOf "aeiou"  >> parserTraced "label" (oneOf "nope")) "atest"
    -- > label: "test"
    -- > label backtracked
    -- > parse error at (line 1, column 2):
    -- > ...
    --
    -- @since 3.1.12.0
    parserTraced :: (Stream s m t, Show t) => String -> ParsecT s u m b -> ParsecT s u m b
    {-# INLINABLE parserTraced #-}
    parserTraced :: forall s (m :: * -> *) t u b.
    (Stream s m t, Show t) =>
    String -> ParsecT s u m b -> ParsecT s u m b
    parserTraced String
    s ParsecT s u m b
    p = do
      String -> ParsecT s u m ()
    forall t s (m :: * -> *) u.
    (Show t, Stream s m t) =>
    String -> ParsecT s u m ()
    parserTrace String
    s
      ParsecT s u m b
    p ParsecT s u m b -> ParsecT s u m b -> ParsecT s u m b
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> String -> ParsecT s u m b -> ParsecT s u m b
    forall a. String -> a -> a
    trace (String
    s String -> String -> String
    forall a. [a] -> [a] -> [a]
    ++ String
    " backtracked") (String -> ParsecT s u m b
    forall (m :: * -> *) a. MonadFail m => String -> m a
    fail String
    s)