Modulemegaparsec-9.8.3Haskell2010

Text.Megaparsec.Char

Commonly used character parsers.

32 values

Packagemegaparsec-9.8.3
Exports32
LanguageHaskell2010
LicenceBSD-2-Clause
SourceChar.hs

Simple parsers

8 declarations

valuenewline :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a newline character.

valuecrlf :: (MonadParsec e s m, Token s ~ Char) => m (Tokens s)

Parse a carriage return character followed by a newline character. Return the sequence of characters parsed.

valueeol :: (MonadParsec e s m, Token s ~ Char) => m (Tokens s)

Parse a CRLF (see crlf) or LF (see newline) end of line. Return the sequence of characters parsed.

valuetab :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a tab character.

valuespace :: (MonadParsec e s m, Token s ~ Char) => m ()

Skip zero or more white space characters.

Categories of characters

20 declarations

valuecontrolChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a control character (a non-printing character of the Latin-1 subset of Unicode).

valuespaceChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a Unicode space character, and the control characters: tab, newline, carriage return, form feed, and vertical tab.

valueupperChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse an upper-case or title-case alphabetic Unicode character. Title case is used by a small number of letter ligatures like the single-character form of Lj.

valuelowerChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a lower-case alphabetic Unicode character.

valueletterChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse an alphabetic Unicode character: lower-case, upper-case, or title-case letter, or a letter of case-less scripts/modifier letter.

valuealphaNumChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse an alphabetic or numeric digit Unicode character.

Note that the numeric digits outside the ASCII range are parsed by this parser but not by digitChar. Such digits may be part of identifiers but are not used by the printer and reader to represent numbers.

valueprintChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a printable Unicode character: letter, number, mark, punctuation, symbol, or space.

valuedigitChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse an ASCII digit, i.e. between “0” and “9”.

valuebinDigitChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a binary digit, i.e. "0" or "1".

valueoctDigitChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse an octal digit, i.e. between “0” and “7”.

valuehexDigitChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a hexadecimal digit, i.e. between “0” and “9”, or “a” and “f”, or “A” and “F”.

valuemarkChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a Unicode mark character (accents and the like), which combines with preceding characters.

valuenumberChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a Unicode numeric character, including digits from various scripts, Roman numerals, etc.

valuepunctuationChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a Unicode punctuation character, including various kinds of connectors, brackets, and quotes.

valuesymbolChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a Unicode symbol character, including mathematical and currency symbols.

valueseparatorChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a Unicode space or separator character.

valueasciiChar :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a character from the first 128 characters of the Unicode character set, corresponding to the ASCII character set.

valuelatin1Char :: (MonadParsec e s m, Token s ~ Char) => m (Token s)

Parse a character from the first 256 characters of the Unicode character set, corresponding to the ISO 8859-1 (Latin-1) character set.

valuecharCategory

:: (MonadParsec e s m, Token s ~ Char)
=> GeneralCategory
-> m (Token s)

charCategory cat parses a character in the Unicode General Category cat; see GeneralCategory.

valuecategoryName :: GeneralCategory -> String

Return the human-readable name of a Unicode General Category.

Single character

2 declarations

valuechar :: (MonadParsec e s m, Token s ~ Char) => Token s -> m (Token s)

A type-constrained version of single.

semicolon = char ';'

valuechar' :: (MonadParsec e s m, Token s ~ Char) => Token s -> m (Token s)

The same as char but case-insensitive. This parser returns the actually parsed character preserving its case.

Example2 expressions

>>> parseTest (char' 'e') "E"'E'>>> parseTest (char' 'e') "G"1:1:unexpected 'G'expecting 'E' or 'e'

Sequence of characters

2 declarations

valuestring :: MonadParsec e s m => Tokens s -> m (Tokens s)

A synonym for chunk.

valuestring'

:: (MonadParsec e s m, FoldCase (Tokens s))
=> Tokens s
-> m (Tokens s)

The same as string, but case-insensitive. On success returns the string cased as the parsed input.

Example1 expression

>>> parseTest (string' "foobar") "foObAr""foObAr"