Idris2Doc : Text.Lexer


alpha : Lexer
Recognise a single alpha character
alphaNum : Lexer
Recognise an alphanumeric character
alphaNums : Lexer
Recognise one or more alphanumeric characters
alphas : Lexer
Recognise one or more alpha characters
any : Lexer
Recognise any character.
approx : String -> Lexer
Recognise a specific string (case-insensitive).
Fails if the string is empty.
blockComment : Lexer -> Lexer -> Lexer
Recognise all input between `start` and `end` lexers.
Supports balanced nesting.

For block comments that don't support nesting (such as C-style comments),
use `surround`
charLit : Lexer
Recognise a character literal, including escaped characters.
(Note: doesn't yet handle escape sequences such as \123)
choice : Foldablet => t (Recognisec) -> Recognisec
Recognise the first matching recogniser in a container. Consumes input if
recognisers in the list consume. Fails if the container is empty.
choiceMap : Foldablet => (a -> Recognisec) -> ta -> Recognisec
Produce recognisers by applying a function to elements of a container, and
recognise the first match. Consumes input if the function produces consuming
recognisers. Fails if the container is empty.
concat : (xs : List (Recognisec)) -> Recognise (c&& Delay (isConsxs))
Sequence a list of recognisers. Guaranteed to consume input if the list is
non-empty and the recognisers consume.
control : Lexer
controls : Lexer
Recognise one or more control characters
count : (q : Quantity) -> Lexer -> Recognise (isSucc (minq))
Recognise a sub-lexer repeated as specified by `q`. Fails if `q` has
`min` and `max` in the wrong order. Consumes input unless `min q` is zero.
digit : Lexer
Recognise a single digit 0-9
digits : Lexer
Recognise one or more digits
escape : Char -> Lexer -> Lexer
Recognise an escape character (often '\\') followed by a sub-lexer
exact : String -> Lexer
Recognise a specific string.
Fails if the string is empty.
hexDigit : Lexer
Recognise a single hexidecimal digit
hexDigits : Lexer
Recognise one or more hexidecimal digits
hexLit : Lexer
Recognise a hexidecimal literal, prefixed by "0x" or "0X"
intLit : Lexer
Recognise an integer literal (possibly with a '-' prefix)
is : Char -> Lexer
Recognise a specific character.
isNot : Char -> Lexer
Recognise anything but the given character.
like : Char -> Lexer
Recognise a specific character (case-insensitive).
lineComment : Lexer -> Lexer
Recognise `start`, then recognise all input until a newline is encountered,
and consume the newline. Will succeed if end-of-input is encountered before
a newline.
lower : Lexer
Recognise a lowercase alpha character
lowers : Lexer
Recognise one or more lowercase alpha characters
many : Lexer -> RecogniseFalse
Recognise a sequence of at zero or more sub-lexers. This is not
guaranteed to consume input
manyThen : Recognisec -> Lexer -> Recognisec
Repeat the sub-lexer `l` zero or more times until the lexer
`stopAfter` is encountered, and consume it. Guaranteed to
consume if `stopAfter` consumes.
manyTill : Lexer -> Lexer -> RecogniseFalse
Recognise many instances of `l` until an instance of `end` is

Useful for defining comments.
manyUntil : Recognisec -> Lexer -> RecogniseFalse
Repeat the sub-lexer `l` zero or more times until the lexer
`stopBefore` is encountered. `stopBefore` will not be consumed.
Not guaranteed to consume input.
newline : Lexer
Recognise a single newline sequence. Understands CRLF, CR, and LF
newlines : Lexer
Recognise one or more newline sequences. Understands CRLF, CR, and LF
non : Lexer -> Lexer
Recognise any character if the sub-lexer `l` fails.
notLike : Char -> Lexer
Recognise anything but the given character (case-insensitive).
octDigit : Lexer
Recognise a single octal digit
octDigits : Lexer
Recognise one or more octal digits
oneOf : String -> Lexer
Recognise any of the characters in the given string.
opt : Lexer -> RecogniseFalse
Recognise a lexer or recognise no input. This is not guaranteed
to consume input.
quote : Lexer -> Lexer -> Lexer
Recognise zero or more occurrences of a sub-lexer surrounded
by the same quote lexer on both sides (useful for strings)
range : Char -> Char -> Lexer
Recognise a character range. Also works in reverse!
some : Lexer -> Lexer
Recognise a sequence of at least one sub-lexers
space : Lexer
Recognise a single whitespace character
spaces : Lexer
Recognise one or more whitespace characters
stringLit : Lexer
Recognise a string literal, including escaped characters.
(Note: doesn't yet handle escape sequences such as \123)
surround : Lexer -> Lexer -> Lexer -> Lexer
Recognise zero or more occurrences of a sub-lexer between
delimiting lexers
symbol : Lexer
Recognise a single non-whitespace, non-alphanumeric character
symbols : Lexer
Recognise one or more non-whitespace, non-alphanumeric characters
toTokenMap : List (Lexer, k) -> TokenMap (Tokenk)
upper : Lexer
Recognise an uppercase alpha character
uppers : Lexer
Recognise one or more uppercase alpha characters