    {-# LANGUAGE CPP, FlexibleContexts, Safe #-}

    -----------------------------------------------------------------------------
    -- |
    -- Module      :  Text.Parsec.Char
    -- 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 character parsers.
    --
    -----------------------------------------------------------------------------

    module Text.Parsec.Char where

    import Data.Char (isSpace, isUpper, isLower, isAlphaNum, isAlpha, isDigit, isHexDigit, isOctDigit)
    #if !(MIN_VERSION_base(4,8,0))
    import Control.Applicative ((*>))
    #endif

    import Text.Parsec.Pos
    import Text.Parsec.Prim

    -- | @oneOf cs@ succeeds if the current character is in the supplied
    -- list of characters @cs@. Returns the parsed character. See also
    -- 'satisfy'.
    --
    -- >   vowel  = oneOf "aeiou"

    oneOf :: (Stream s m Char) => [Char] -> ParsecT s u m Char
    {-# INLINABLE oneOf #-}
    oneOf :: forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    oneOf [Char]
    cs            = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (\Char
    c -> Char -> [Char] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    elem Char
    c [Char]
    cs)

    -- | As the dual of 'oneOf', @noneOf cs@ succeeds if the current
    -- character /not/ in the supplied list of characters @cs@. Returns the
    -- parsed character.
    --
    -- >  consonant = noneOf "aeiou"

    noneOf :: (Stream s m Char) => [Char] -> ParsecT s u m Char
    {-# INLINABLE noneOf #-}
    noneOf :: forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m Char
    noneOf [Char]
    cs           = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (\Char
    c -> Bool -> Bool
    not (Char -> [Char] -> Bool
    forall (t :: * -> *) a. (Foldable t, Eq a) => a -> t a -> Bool
    elem Char
    c [Char]
    cs))

    -- | Skips /zero/ or more white space characters. See also 'skipMany'.

    spaces :: (Stream s m Char) => ParsecT s u m ()
    {-# INLINABLE spaces #-}
    spaces :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m ()
    spaces              = ParsecT s u m Char -> ParsecT s u m ()
    forall s u (m :: * -> *) a. ParsecT s u m a -> ParsecT s u m ()
    skipMany ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    space        ParsecT s u m () -> [Char] -> ParsecT s u m ()
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "white space"

    -- | Parses a white space character (any character which satisfies 'isSpace')
    -- Returns the parsed character.

    space :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE space #-}
    space :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    space               = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isSpace       ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "space"

    -- | Parses a newline character (\'\\n\'). Returns a newline character.

    newline :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE newline #-}
    newline :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline             = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    '\n'             ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "lf new-line"

    -- | Parses a carriage return character (\'\\r\') followed by a newline character (\'\\n\').
    -- Returns a newline character.

    crlf :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE crlf #-}
    crlf :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    crlf                = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    '\r' ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
    forall (f :: * -> *) a b. Applicative f => f a -> f b -> f b
    *> Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    '\n' ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "crlf new-line"

    -- | Parses a CRLF (see 'crlf') or LF (see 'newline') end-of-line.
    -- Returns a newline character (\'\\n\').
    --
    -- > endOfLine = newline <|> crlf
    --

    endOfLine :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE endOfLine #-}
    endOfLine :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    endOfLine           = ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    newline ParsecT s u m Char -> ParsecT s u m Char -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> ParsecT s u m a -> ParsecT s u m a
    <|> ParsecT s u m Char
    forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    crlf       ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "new-line"

    -- | Parses a tab character (\'\\t\'). Returns a tab character.

    tab :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE tab #-}
    tab :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    tab                 = Char -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    '\t'             ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "tab"

    -- | Parses an upper case letter (according to 'isUpper').
    -- Returns the parsed character.

    upper :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE upper #-}
    upper :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    upper               = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isUpper       ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "uppercase letter"

    -- | Parses a lower case character (according to 'isLower').
    -- Returns the parsed character.

    lower :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE lower #-}
    lower :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    lower               = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isLower       ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "lowercase letter"

    -- | Parses a alphabetic or numeric Unicode characters
    -- according to 'isAlphaNum'. Returns the parsed character.
    --
    -- Note that numeric digits outside the ASCII range (such as arabic-indic digits like e.g. \"٤\" or @U+0664@),
    -- as well as numeric characters which aren't digits, are parsed by this function
    -- but not by 'digit'.

    alphaNum :: (Stream s m Char => ParsecT s u m Char)
    {-# INLINABLE alphaNum #-}
    alphaNum :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    alphaNum            = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isAlphaNum    ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "letter or digit"

    -- | Parses an alphabetic Unicode characters (lower-case, upper-case and title-case letters,
    -- plus letters of caseless scripts and modifiers letters according to 'isAlpha').
    -- Returns the parsed character.

    letter :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE letter #-}
    letter :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    letter              = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isAlpha       ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "letter"

    -- | Parses an ASCII digit. Returns the parsed character.

    digit :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE digit #-}
    digit :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    digit               = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isDigit       ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "digit"

    -- | Parses a hexadecimal digit (a digit or a letter between \'a\' and
    -- \'f\' or \'A\' and \'F\'). Returns the parsed character.

    hexDigit :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE hexDigit #-}
    hexDigit :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    hexDigit            = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isHexDigit    ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "hexadecimal digit"

    -- | Parses an octal digit (a character between \'0\' and \'7\'). Returns
    -- the parsed character.

    octDigit :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE octDigit #-}
    octDigit :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    octDigit            = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    isOctDigit    ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char]
    "octal digit"

    -- | @char c@ parses a single character @c@. Returns the parsed
    -- character (i.e. @c@).
    --
    -- >  semiColon  = char ';'

    char :: (Stream s m Char) => Char -> ParsecT s u m Char
    {-# INLINABLE char #-}
    char :: forall s (m :: * -> *) u.
    Stream s m Char =>
    Char -> ParsecT s u m Char
    char Char
    c              = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (Char -> Char -> Bool
    forall a. Eq a => a -> a -> Bool
    ==Char
    c)  ParsecT s u m Char -> [Char] -> ParsecT s u m Char
    forall s u (m :: * -> *) a.
    ParsecT s u m a -> [Char] -> ParsecT s u m a
    <?> [Char] -> [Char]
    forall a. Show a => a -> [Char]
    show [Char
    c]

    -- | This parser succeeds for any character. Returns the parsed character.

    anyChar :: (Stream s m Char) => ParsecT s u m Char
    {-# INLINABLE anyChar #-}
    anyChar :: forall s (m :: * -> *) u. Stream s m Char => ParsecT s u m Char
    anyChar             = (Char -> Bool) -> ParsecT s u m Char
    forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy (Bool -> Char -> Bool
    forall a b. a -> b -> a
    const Bool
    True)

    -- | The parser @satisfy f@ succeeds for any character for which the
    -- supplied function @f@ returns 'True'. Returns the character that is
    -- actually parsed.

    -- >  digit     = satisfy isDigit
    -- >  oneOf cs  = satisfy (\c -> c `elem` cs)

    satisfy :: (Stream s m Char) => (Char -> Bool) -> ParsecT s u m Char
    {-# INLINABLE satisfy #-}
    satisfy :: forall s (m :: * -> *) u.
    Stream s m Char =>
    (Char -> Bool) -> ParsecT s u m Char
    satisfy Char -> Bool
    f           = (Char -> [Char])
    -> (SourcePos -> Char -> s -> SourcePos)
    -> (Char -> Maybe Char)
    -> ParsecT s u m Char
    forall s (m :: * -> *) t a u.
    Stream s m t =>
    (t -> [Char])
    -> (SourcePos -> t -> s -> SourcePos)
    -> (t -> Maybe a)
    -> ParsecT s u m a
    tokenPrim (\Char
    c -> [Char] -> [Char]
    forall a. Show a => a -> [Char]
    show [Char
    c])
                                    (\SourcePos
    pos Char
    c s
    _cs -> SourcePos -> Char -> SourcePos
    updatePosChar SourcePos
    pos Char
    c)
                                    (\Char
    c -> if Char -> Bool
    f Char
    c then Char -> Maybe Char
    forall a. a -> Maybe a
    Just Char
    c else Maybe Char
    forall a. Maybe a
    Nothing)

    -- | @string s@ parses a sequence of characters given by @s@. Returns
    -- the parsed string (i.e. @s@).
    --
    -- >  divOrMod    =   string "div"
    -- >              <|> string "mod"

    string :: (Stream s m Char) => String -> ParsecT s u m String
    {-# INLINABLE string #-}
    string :: forall s (m :: * -> *) u.
    Stream s m Char =>
    [Char] -> ParsecT s u m [Char]
    string [Char]
    s            = ([Char] -> [Char])
    -> (SourcePos -> [Char] -> SourcePos)
    -> [Char]
    -> ParsecT s u m [Char]
    forall s (m :: * -> *) t u.
    (Stream s m t, Eq t) =>
    ([t] -> [Char])
    -> (SourcePos -> [t] -> SourcePos) -> [t] -> ParsecT s u m [t]
    tokens [Char] -> [Char]
    forall a. Show a => a -> [Char]
    show SourcePos -> [Char] -> SourcePos
    updatePosString [Char]
    s