Idris2Doc : Text.Lexer

Text.Lexer

alpha : Lexer
Recognise a single alpha character
/[A-Za-z]/
alphaNum : Lexer
Recognise an alphanumeric character
/[A-Za-z0-9]/
alphaNums : Lexer
Recognise one or more alphanumeric characters
/[A-Za-z0-9]+/
alphas : Lexer
Recognise one or more alpha characters
/[A-Za-z]+/
any : Lexer
Recognise any character.
/./
approx : String -> Lexer
Recognise a specific string (case-insensitive).
Fails if the string is empty.
/`str`/i
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
/[\\x00-\\x1f\\x7f-\\x9f]+/
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.
/`l`{`q`}/
digit : Lexer
Recognise a single digit 0-9
/[0-9]/
digits : Lexer
Recognise one or more digits
/[0-9]+/
escape : Char -> Lexer -> Lexer
Recognise an escape character (often '\\') followed by a sub-lexer
/[`esc`]`l`/
exact : String -> Lexer
Recognise a specific string.
Fails if the string is empty.
/`str`/
hexDigit : Lexer
Recognise a single hexidecimal digit
/[0-9A-Fa-f]/
hexDigits : Lexer
Recognise one or more hexidecimal digits
/[0-9A-Fa-f]+/
hexLit : Lexer
Recognise a hexidecimal literal, prefixed by "0x" or "0X"
/0[Xx][0-9A-Fa-f]+/
intLit : Lexer
Recognise an integer literal (possibly with a '-' prefix)
/-?[0-9]+/
is : Char -> Lexer
Recognise a specific character.
/[`x`]/
isNot : Char -> Lexer
Recognise anything but the given character.
/[\^`x`]/
like : Char -> Lexer
Recognise a specific character (case-insensitive).
/[`x`]/i
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.
/`start`[\^\\r\\n]+(\\r\\n|[\\r\\n])?/
lower : Lexer
Recognise a lowercase alpha character
/[a-z]/
lowers : Lexer
Recognise one or more lowercase alpha characters
/[a-z]+/
many : Lexer -> RecogniseFalse
Recognise a sequence of at zero or more sub-lexers. This is not
guaranteed to consume input
/`l`\*/
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.
/`l`\*?`stopAfter`/
manyTill : Lexer -> Lexer -> RecogniseFalse
Recognise many instances of `l` until an instance of `end` is
encountered.

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.
/((?!`stopBefore`)`l`)\*/
newline : Lexer
Recognise a single newline sequence. Understands CRLF, CR, and LF
/\\r\\n|[\\r\\n]/
newlines : Lexer
Recognise one or more newline sequences. Understands CRLF, CR, and LF
/(\\r\\n|[\\r\\n])+)/
non : Lexer -> Lexer
Recognise any character if the sub-lexer `l` fails.
/(?!`l`)./
notLike : Char -> Lexer
Recognise anything but the given character (case-insensitive).
/[\^`x`]/i
octDigit : Lexer
Recognise a single octal digit
/[0-8]/
octDigits : Lexer
Recognise one or more octal digits
/[0-8]+/
oneOf : String -> Lexer
Recognise any of the characters in the given string.
/[`chars`]/
opt : Lexer -> RecogniseFalse
Recognise a lexer or recognise no input. This is not guaranteed
to consume input.
/`l`?/
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)
/`q`(`l`)\*?`q`/
range : Char -> Char -> Lexer
Recognise a character range. Also works in reverse!
/[`start`-`end`]/
some : Lexer -> Lexer
Recognise a sequence of at least one sub-lexers
/`l`+/
space : Lexer
Recognise a single whitespace character
/\\s/
spaces : Lexer
Recognise one or more whitespace characters
/\\s+/
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
/`start`(`l`)\*?`end`/
symbol : Lexer
Recognise a single non-whitespace, non-alphanumeric character
/[\^\\sA-Za-z0-9]/
symbols : Lexer
Recognise one or more non-whitespace, non-alphanumeric characters
/[\^\\sA-Za-z0-9]+/
toTokenMap : List (Lexer, k) -> TokenMap (Tokenk)
upper : Lexer
Recognise an uppercase alpha character
/[A-Z]/
uppers : Lexer
Recognise one or more uppercase alpha characters
/[A-Z]+/