    {-# LANGUAGE OverloadedStrings #-}
    {-# LANGUAGE BangPatterns #-}
    module Commonmark.TokParsers
      ( satisfyTok
      , satisfyWord
      , anyTok
      , anySymbol
      , symbol
      , whitespace
      , lineEnd
      , spaceTok
      , oneOfToks
      , noneOfToks
      , gobbleSpaces
      , gobbleUpToSpaces
      , withRaw
      , hasType
      , textIs
      , blankLine
      , restOfLine
      , isOneOfCI
      , nonindentSpaces
      , skipManyTill
      , skipWhile
      )
      where
    import           Control.Monad   (mzero, void)
    import           Data.Text       (Text)
    import qualified Data.Text       as T
    import           Text.Parsec
    import           Text.Parsec.Pos (updatePosString)
    import           Commonmark.Tokens

    -- | Parses a single 'Tok' satisfying a predicate.
    satisfyTok :: Monad m => (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok :: forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok Tok -> Bool
    f = (Tok -> String)
    -> (SourcePos -> Tok -> [Tok] -> SourcePos)
    -> (Tok -> Maybe Tok)
    -> ParsecT [Tok] s m Tok
    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 (Text -> String
    T.unpack (Text -> String) -> (Tok -> Text) -> Tok -> String
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . Tok -> Text
    tokContents) SourcePos -> Tok -> [Tok] -> SourcePos
    updatePos Tok -> Maybe Tok
    matcher
      where matcher :: Tok -> Maybe Tok
    matcher Tok
    t | Tok -> Bool
    f Tok
    t       = Tok -> Maybe Tok
    forall a. a -> Maybe a
    Just Tok
    t
                      | Bool
    otherwise = Maybe Tok
    forall a. Maybe a
    Nothing
            updatePos :: SourcePos -> Tok -> [Tok] -> SourcePos
            updatePos :: SourcePos -> Tok -> [Tok] -> SourcePos
    updatePos SourcePos
    _spos Tok
    _ (Tok TokType
    _ !SourcePos
    pos Text
    _ : [Tok]
    _) = SourcePos
    pos
            updatePos !SourcePos
    spos (Tok TokType
    _ SourcePos
    _pos !Text
    t) []    =
              SourcePos -> String -> SourcePos
    updatePosString SourcePos
    spos (Text -> String
    T.unpack Text
    t)
    {-# INLINE satisfyTok #-}

    -- | Parses any 'Tok'.
    anyTok :: Monad m => ParsecT [Tok] s m Tok
    anyTok :: forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m Tok
    anyTok = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (Bool -> Tok -> Bool
    forall a b. a -> b -> a
    const Bool
    True)
    {-# INLINE anyTok #-}

    -- | Parses any 'Symbol' 'Tok'.
    anySymbol :: Monad m => ParsecT [Tok] s m Tok
    anySymbol :: forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m Tok
    anySymbol = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (\Tok
    t -> case Tok -> TokType
    tokType Tok
    t of
                                        Symbol Char
    _ -> Bool
    True
                                        TokType
    _        -> Bool
    False)
    {-# INLINE anySymbol #-}

    -- | Parses a 'Symbol' with character @c@.
    symbol ::  Monad m => Char -> ParsecT [Tok] s m Tok
    symbol :: forall (m :: * -> *) s. Monad m => Char -> ParsecT [Tok] s m Tok
    symbol Char
    c = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (TokType -> Tok -> Bool
    hasType (Char -> TokType
    Symbol Char
    c))
    {-# INLINE symbol #-}

    -- | Parses a 'Tok' with one of the listed types.
    oneOfToks ::  Monad m => [TokType] -> ParsecT [Tok] s m Tok
    oneOfToks :: forall (m :: * -> *) s.
    Monad m =>
    [TokType] -> ParsecT [Tok] s m Tok
    oneOfToks [TokType]
    toktypes = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok ([TokType] -> Tok -> Bool
    hasTypeIn [TokType]
    toktypes)
    {-# INLINE oneOfToks #-}

    -- | Parses a 'Tok' with none of the listed types.
    noneOfToks ::  Monad m => [TokType] -> ParsecT [Tok] s m Tok
    noneOfToks :: forall (m :: * -> *) s.
    Monad m =>
    [TokType] -> ParsecT [Tok] s m Tok
    noneOfToks [TokType]
    toktypes = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (Bool -> Bool
    not (Bool -> Bool) -> (Tok -> Bool) -> Tok -> Bool
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . [TokType] -> Tok -> Bool
    hasTypeIn [TokType]
    toktypes)
    {-# INLINE noneOfToks #-}

    -- | Parses one or more whitespace 'Tok's.
    whitespace ::  Monad m => ParsecT [Tok] s m [Tok]
    whitespace :: forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m [Tok]
    whitespace = ParsecT [Tok] s m Tok -> ParsecT [Tok] s m [Tok]
    forall s (m :: * -> *) t u a.
    Stream s m t =>
    ParsecT s u m a -> ParsecT s u m [a]
    many1 (ParsecT [Tok] s m Tok -> ParsecT [Tok] s m [Tok])
    -> ParsecT [Tok] s m Tok -> ParsecT [Tok] s m [Tok]
    forall a b. (a -> b) -> a -> b
    $ (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (\Tok
    t -> case Tok -> TokType
    tokType Tok
    t of
                                             TokType
    Spaces  -> Bool
    True
                                             TokType
    LineEnd -> Bool
    True
                                             TokType
    _       -> Bool
    False)
    {-# INLINE whitespace #-}

    -- | Parses a 'LineEnd' token.
    lineEnd ::  Monad m => ParsecT [Tok] s m Tok
    lineEnd :: forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m Tok
    lineEnd = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (TokType -> Tok -> Bool
    hasType TokType
    LineEnd)
    {-# INLINE lineEnd #-}

    -- | Parses a 'Spaces' token.
    spaceTok :: Monad m => ParsecT [Tok] s m Tok
    spaceTok :: forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m Tok
    spaceTok = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (TokType -> Tok -> Bool
    hasType TokType
    Spaces)
    {-# INLINE spaceTok #-}

    -- | Parses a 'WordChars' token matching a predicate.
    satisfyWord ::  Monad m => (Text -> Bool) -> ParsecT [Tok] s m Tok
    satisfyWord :: forall (m :: * -> *) s.
    Monad m =>
    (Text -> Bool) -> ParsecT [Tok] s m Tok
    satisfyWord Text -> Bool
    f = (Tok -> Bool) -> ParsecT [Tok] s m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (\Tok
    t -> TokType -> Tok -> Bool
    hasType TokType
    WordChars Tok
    t Bool -> Bool -> Bool
    && (Text -> Bool) -> Tok -> Bool
    textIs Text -> Bool
    f Tok
    t)
    {-# INLINE satisfyWord #-}

    -- | Parses exactly @n@ spaces. If tabs are encountered,
    -- they are split into spaces before being consumed; so
    -- a tab may be partially consumed by this parser.
    gobbleSpaces :: Monad m => Int -> ParsecT [Tok] u m Int
    gobbleSpaces :: forall (m :: * -> *) u. Monad m => Int -> ParsecT [Tok] u m Int
    gobbleSpaces Int
    0 = Int -> ParsecT [Tok] u m Int
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int
    0
    gobbleSpaces Int
    n = ParsecT [Tok] u m Int -> ParsecT [Tok] u m Int
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT [Tok] u m Int -> ParsecT [Tok] u m Int)
    -> ParsecT [Tok] u m Int -> ParsecT [Tok] u m Int
    forall a b. (a -> b) -> a -> b
    $ Bool -> Int -> ParsecT [Tok] u m Int
    forall (m :: * -> *) u.
    Monad m =>
    Bool -> Int -> ParsecT [Tok] u m Int
    gobble' Bool
    True Int
    n
    {-# INLINE gobbleSpaces #-}

    -- | Parses up to @n@ spaces.
    gobbleUpToSpaces :: Monad m => Int -> ParsecT [Tok] u m Int
    gobbleUpToSpaces :: forall (m :: * -> *) u. Monad m => Int -> ParsecT [Tok] u m Int
    gobbleUpToSpaces Int
    0 = Int -> ParsecT [Tok] u m Int
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int
    0
    gobbleUpToSpaces Int
    n = Bool -> Int -> ParsecT [Tok] u m Int
    forall (m :: * -> *) u.
    Monad m =>
    Bool -> Int -> ParsecT [Tok] u m Int
    gobble' Bool
    False Int
    n
    {-# INLINE gobbleUpToSpaces #-}

    gobble' :: Monad m => Bool -> Int -> ParsecT [Tok] u m Int
    gobble' :: forall (m :: * -> *) u.
    Monad m =>
    Bool -> Int -> ParsecT [Tok] u m Int
    gobble' Bool
    requireAll Int
    numspaces
      | Int
    numspaces Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    >= Int
    1 = (do
        Tok TokType
    Spaces SourcePos
    pos Text
    _ <- (Tok -> Bool) -> ParsecT [Tok] u m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok (TokType -> Tok -> Bool
    hasType TokType
    Spaces)
        SourcePos
    pos' <- ParsecT [Tok] u m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
        case SourcePos -> Int
    sourceColumn SourcePos
    pos' Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - SourcePos -> Int
    sourceColumn SourcePos
    pos of
             Int
    n | Int
    n Int -> Int -> Bool
    forall a. Ord a => a -> a -> Bool
    < Int
    numspaces  -> (Int -> Int -> Int
    forall a. Num a => a -> a -> a
    + Int
    n) (Int -> Int) -> ParsecT [Tok] u m Int -> ParsecT [Tok] u m Int
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> Bool -> Int -> ParsecT [Tok] u m Int
    forall (m :: * -> *) u.
    Monad m =>
    Bool -> Int -> ParsecT [Tok] u m Int
    gobble' Bool
    requireAll (Int
    numspaces Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    n)
               | Int
    n Int -> Int -> Bool
    forall a. Eq a => a -> a -> Bool
    == Int
    numspaces -> Int -> ParsecT [Tok] u m Int
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ParsecT [Tok] u m Int) -> Int -> ParsecT [Tok] u m Int
    forall a b. (a -> b) -> a -> b
    $! Int
    n
               | Bool
    otherwise      -> do
                   let newpos :: SourcePos
    newpos = SourcePos -> Int -> SourcePos
    incSourceColumn SourcePos
    pos Int
    numspaces
                   let newtok :: Tok
    newtok = TokType -> SourcePos -> Text -> Tok
    Tok TokType
    Spaces SourcePos
    newpos
                          (Int -> Text -> Text
    T.replicate (Int
    n Int -> Int -> Int
    forall a. Num a => a -> a -> a
    - Int
    numspaces) Text
    " ")
                   ParsecT [Tok] u m [Tok]
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput ParsecT [Tok] u m [Tok]
    -> ([Tok] -> ParsecT [Tok] u m ()) -> ParsecT [Tok] u m ()
    forall a b.
    ParsecT [Tok] u m a
    -> (a -> ParsecT [Tok] u m b) -> ParsecT [Tok] u m b
    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
    >>= [Tok] -> ParsecT [Tok] u m ()
    forall (m :: * -> *) s u. Monad m => s -> ParsecT s u m ()
    setInput ([Tok] -> ParsecT [Tok] u m ())
    -> ([Tok] -> [Tok]) -> [Tok] -> ParsecT [Tok] u m ()
    forall b c a. (b -> c) -> (a -> b) -> a -> c
    . (Tok
    newtokTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :)
                   SourcePos -> ParsecT [Tok] u m ()
    forall (m :: * -> *) s u. Monad m => SourcePos -> ParsecT s u m ()
    setPosition SourcePos
    newpos
                   Int -> ParsecT [Tok] u m Int
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (Int -> ParsecT [Tok] u m Int) -> Int -> ParsecT [Tok] u m Int
    forall a b. (a -> b) -> a -> b
    $! Int
    numspaces)
        ParsecT [Tok] u m Int
    -> ParsecT [Tok] u m Int -> ParsecT [Tok] u m Int
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> if Bool
    requireAll
               then ParsecT [Tok] u m Int
    forall a. ParsecT [Tok] u m a
    forall (m :: * -> *) a. MonadPlus m => m a
    mzero
               else Int -> ParsecT [Tok] u m Int
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int
    0
      | Bool
    otherwise     = Int -> ParsecT [Tok] u m Int
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return Int
    0
    {-# INLINE gobble' #-}

    -- | Applies a parser and returns its value (if successful)
    -- plus a list of the raw tokens parsed.
    withRaw :: Monad m => ParsecT [Tok] s m a -> ParsecT [Tok] s m (a, [Tok])
    withRaw :: forall (m :: * -> *) s a.
    Monad m =>
    ParsecT [Tok] s m a -> ParsecT [Tok] s m (a, [Tok])
    withRaw ParsecT [Tok] s m a
    parser = do
      [Tok]
    toks <- ParsecT [Tok] s m [Tok]
    forall (m :: * -> *) s u. Monad m => ParsecT s u m s
    getInput
      a
    res <- ParsecT [Tok] s m a
    parser
      SourcePos
    newpos <- ParsecT [Tok] s m SourcePos
    forall (m :: * -> *) s u. Monad m => ParsecT s u m SourcePos
    getPosition
      let getrawtoks :: [Tok] -> [Tok]
    getrawtoks (Tok
    t:[Tok]
    ts)
            | Tok -> SourcePos
    tokPos Tok
    t SourcePos -> SourcePos -> Bool
    forall a. Ord a => a -> a -> Bool
    < SourcePos
    newpos = Tok
    t Tok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    : [Tok] -> [Tok]
    getrawtoks [Tok]
    ts
          getrawtoks [Tok]
    _ = []
      let rawtoks :: [Tok]
    rawtoks = [Tok] -> [Tok]
    getrawtoks [Tok]
    toks
      (a, [Tok]) -> ParsecT [Tok] s m (a, [Tok])
    forall a. a -> ParsecT [Tok] s m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return (a
    res, [Tok]
    rawtoks)
    {-# INLINE withRaw #-}

    -- | Filters tokens of a certain type.
    hasType :: TokType -> Tok -> Bool
    hasType :: TokType -> Tok -> Bool
    hasType TokType
    ty (Tok TokType
    ty' SourcePos
    _ Text
    _) = TokType
    ty TokType -> TokType -> Bool
    forall a. Eq a => a -> a -> Bool
    == TokType
    ty'
    {-# INLINE hasType #-}

    hasTypeIn :: [TokType] -> Tok -> Bool
    hasTypeIn :: [TokType] -> Tok -> Bool
    hasTypeIn [TokType]
    tys (Tok TokType
    ty' SourcePos
    _ Text
    _) = TokType
    ty' TokType -> [TokType] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [TokType]
    tys

    -- | Filters tokens with certain contents.
    textIs :: (Text -> Bool) -> Tok -> Bool
    textIs :: (Text -> Bool) -> Tok -> Bool
    textIs Text -> Bool
    f (Tok TokType
    _ SourcePos
    _ Text
    t) = Text -> Bool
    f Text
    t
    {-# INLINE textIs #-}

    -- | Gobble up to 3 spaces (may be part of a tab).
    nonindentSpaces :: Monad m => ParsecT [Tok] u m ()
    nonindentSpaces :: forall (m :: * -> *) u. Monad m => ParsecT [Tok] u m ()
    nonindentSpaces = ParsecT [Tok] u m Int -> ParsecT [Tok] u m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void (ParsecT [Tok] u m Int -> ParsecT [Tok] u m ())
    -> ParsecT [Tok] u m Int -> ParsecT [Tok] u m ()
    forall a b. (a -> b) -> a -> b
    $ Int -> ParsecT [Tok] u m Int
    forall (m :: * -> *) u. Monad m => Int -> ParsecT [Tok] u m Int
    gobbleUpToSpaces Int
    3
    {-# INLINE nonindentSpaces #-}

    -- | Case-insensitive membership in a list of 'Text's.
    isOneOfCI :: [Text] -> Text -> Bool
    isOneOfCI :: [Text] -> Text -> Bool
    isOneOfCI [Text]
    ts Text
    t = Text -> Text
    T.toLower Text
    t Text -> [Text] -> Bool
    forall a. Eq a => a -> [a] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    `elem` [Text]
    ts
    {-# INLINE isOneOfCI #-}

    -- | Apply @p@ many times until @stop@ succeeds, discarding results.
    skipManyTill :: ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m ()
    skipManyTill :: forall s u (m :: * -> *) a b.
    ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m ()
    skipManyTill ParsecT s u m a
    p ParsecT s u m b
    stop = ParsecT s u m ()
    scan
        where scan :: ParsecT s u m ()
    scan = (() () -> ParsecT s u m b -> ParsecT s u m ()
    forall a b. a -> ParsecT s u m b -> ParsecT s u m a
    forall (f :: * -> *) a b. Functor f => a -> f b -> f a
    <$ ParsecT s u m b
    stop) 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 a
    p ParsecT s u m a -> ParsecT s u m () -> ParsecT s u m ()
    forall a b. ParsecT s u m a -> ParsecT s u m b -> ParsecT s u m b
    forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
    >> ParsecT s u m ()
    scan)
    {-# INLINE skipManyTill #-}

    -- | Efficiently skip 'Tok's satisfying a certain condition.
    skipWhile :: Monad m => (Tok -> Bool) -> ParsecT [Tok] u m ()
    skipWhile :: forall (m :: * -> *) u.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] u m ()
    skipWhile Tok -> Bool
    f = ParsecT [Tok] u m Tok -> ParsecT [Tok] u m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ((Tok -> Bool) -> ParsecT [Tok] u m Tok
    forall (m :: * -> *) s.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] s m Tok
    satisfyTok Tok -> Bool
    f)
    {-# INLINE skipWhile #-}

    -- | Parse optional spaces and an endline.
    blankLine :: Monad m => ParsecT [Tok] s m ()
    blankLine :: forall (m :: * -> *) u. Monad m => ParsecT [Tok] u m ()
    blankLine = ParsecT [Tok] s m () -> ParsecT [Tok] s m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m a
    try (ParsecT [Tok] s m () -> ParsecT [Tok] s m ())
    -> ParsecT [Tok] s m () -> ParsecT [Tok] s m ()
    forall a b. (a -> b) -> a -> b
    $ do
      (Tok -> Bool) -> ParsecT [Tok] s m ()
    forall (m :: * -> *) u.
    Monad m =>
    (Tok -> Bool) -> ParsecT [Tok] u m ()
    skipWhile (TokType -> Tok -> Bool
    hasType TokType
    Spaces)
      ParsecT [Tok] s m Tok -> ParsecT [Tok] s m ()
    forall (f :: * -> *) a. Functor f => f a -> f ()
    void ParsecT [Tok] s m Tok
    forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m Tok
    lineEnd
    {-# INLINE blankLine #-}

    -- | Efficiently parse the remaining tokens on a line,
    -- including the LineEnd (if any).
    restOfLine :: Monad m => ParsecT [Tok] s m [Tok]
    restOfLine :: forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m [Tok]
    restOfLine = ParsecT [Tok] s m [Tok]
    forall {u}. ParsecT [Tok] u m [Tok]
    go
      where
       go :: ParsecT [Tok] u m [Tok]
    go = [Tok] -> ParsecT [Tok] u m [Tok] -> ParsecT [Tok] u m [Tok]
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    a -> ParsecT s u m a -> ParsecT s u m a
    option [] (ParsecT [Tok] u m [Tok] -> ParsecT [Tok] u m [Tok])
    -> ParsecT [Tok] u m [Tok] -> ParsecT [Tok] u m [Tok]
    forall a b. (a -> b) -> a -> b
    $ do
         !Tok
    tok <- ParsecT [Tok] u m Tok
    forall (m :: * -> *) s. Monad m => ParsecT [Tok] s m Tok
    anyTok
         case Tok -> TokType
    tokType Tok
    tok of
           TokType
    LineEnd -> [Tok] -> ParsecT [Tok] u m [Tok]
    forall a. a -> ParsecT [Tok] u m a
    forall (m :: * -> *) a. Monad m => a -> m a
    return [Tok
    tok]
           TokType
    _       -> (Tok
    tokTok -> [Tok] -> [Tok]
    forall a. a -> [a] -> [a]
    :) ([Tok] -> [Tok])
    -> ParsecT [Tok] u m [Tok] -> ParsecT [Tok] u m [Tok]
    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
    <$> ParsecT [Tok] u m [Tok]
    go
    {-# INLINE restOfLine #-}