Idris2Doc : Text.Lexer

Text.Lexer

alpha : Lexer
  Recognise a single alpha character
/[A-Za-z]/

Totality: total
alphaNum : Lexer
  Recognise an alphanumeric character
/[A-Za-z0-9]/

Totality: total
alphaNums : Lexer
  Recognise one or more alphanumeric characters
/[A-Za-z0-9]+/

Totality: total
alphas : Lexer
  Recognise one or more alpha characters
/[A-Za-z]+/

Totality: total
any : Lexer
  Recognise any character.
/./

Totality: total
approx : String -> Lexer
  Recognise a specific string (case-insensitive).
Fails if the string is empty.
/`str`/i

Totality: total
binDigit : Lexer
  Recognise a single binary digit
/[0-1]/

Totality: total
binDigits : Lexer
  Recognise one or more binary digits
/[0-1]+/

Totality: total
binLit : Lexer
  Recognise a binary literal, prefixed by "0b"
/0b[0-1]+/

Totality: total
binUnderscoredLit : Lexer
Totality: total
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`

Totality: total
charLit : Lexer
  Recognise a character literal, including escaped characters.
(Note: doesn't yet handle escape sequences such as \123)
/'(\\\\.|[\^'])'/

Totality: total
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.

Totality: total
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.

Totality: total
concat : (xs : List (Recognisec)) -> Recognise (isConsxs&& Delay c)
  Sequence a list of recognisers. Guaranteed to consume input if the list is
non-empty and the recognisers consume.

Totality: total
control : Lexer
Totality: total
controls : Lexer
  Recognise one or more control characters
/[\\x00-\\x1f\\x7f-\\x9f]+/

Totality: total
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`}/

Totality: total
digit : Lexer
  Recognise a single digit 0-9
/[0-9]/

Totality: total
digits : Lexer
  Recognise one or more digits
/[0-9]+/

Totality: total
digitsUnderscoredLit : Lexer
Totality: total
escape : Lexer -> Lexer -> Lexer
  Recognise an escape sub-lexer (often '\\') followed by
another sub-lexer
/[`esc`]`l`/

Totality: total
exact : String -> Lexer
  Recognise a specific string.
Fails if the string is empty.
/`str`/

Totality: total
hexDigit : Lexer
  Recognise a single hexidecimal digit
/[0-9A-Fa-f]/

Totality: total
hexDigits : Lexer
  Recognise one or more hexidecimal digits
/[0-9A-Fa-f]+/

Totality: total
hexLit : Lexer
  Recognise a hexidecimal literal, prefixed by "0x" or "0X"
/0[Xx][0-9A-Fa-f]+/

Totality: total
hexUnderscoredLit : Lexer
Totality: total
intLit : Lexer
  Recognise an integer literal (possibly with a '-' prefix)
/-?[0-9]+/

Totality: total
is : Char -> Lexer
  Recognise a specific character.
/[`x`]/

Totality: total
isNot : Char -> Lexer
  Recognise anything but the given character.
/[\^`x`]/

Totality: total
like : Char -> Lexer
  Recognise a specific character (case-insensitive).
/[`x`]/i

Totality: total
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])?/

Totality: total
lower : Lexer
  Recognise a lowercase alpha character
/[a-z]/

Totality: total
lowers : Lexer
  Recognise one or more lowercase alpha characters
/[a-z]+/

Totality: total
many : Lexer -> RecogniseFalse
  Recognise a sequence of at zero or more sub-lexers. This is not
guaranteed to consume input
/`l`\*/

Totality: total
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`/

Totality: total
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`)\*/

Totality: total
newline : Lexer
  Recognise a single newline sequence. Understands CRLF, CR, and LF
/\\r\\n|[\\r\\n]/

Totality: total
newlines : Lexer
  Recognise one or more newline sequences. Understands CRLF, CR, and LF
/(\\r\\n|[\\r\\n])+)/

Totality: total
non : Lexer -> Lexer
  Recognise any character if the sub-lexer `l` fails.
/(?!`l`)./

Totality: total
notLike : Char -> Lexer
  Recognise anything but the given character (case-insensitive).
/[\^`x`]/i

Totality: total
octDigit : Lexer
  Recognise a single octal digit
/[0-8]/

Totality: total
octDigits : Lexer
  Recognise one or more octal digits
/[0-8]+/

Totality: total
octLit : Lexer
  Recognise an octal literal, prefixed by "0o"
/0o[0-9A-Fa-f]+/

Totality: total
octUnderscoredLit : Lexer
Totality: total
oneOf : String -> Lexer
  Recognise any of the characters in the given string.
/[`chars`]/

Totality: total
opt : Lexer -> RecogniseFalse
  Recognise a lexer or recognise no input. This is not guaranteed
to consume input.
/`l`?/

Totality: total
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`/

Totality: total
range : Char -> Char -> Lexer
  Recognise a character range. Also works in reverse!
/[`start`-`end`]/

Totality: total
some : Lexer -> Lexer
  Recognise a sequence of at least one sub-lexers
/`l`+/

Totality: total
someUntil : Recognisec -> Lexer -> Lexer
  Repeat the sub-lexer `l` one or more times until the lexer
`stopBefore` is encountered. `stopBefore` will not be consumed.
/((?!`stopBefore`)`l`)\+/

Totality: total
space : Lexer
  Recognise a single whitespace character
/\\s/

Totality: total
spaces : Lexer
  Recognise one or more whitespace characters
/\\s+/

Totality: total
stringLit : Lexer
  Recognise a string literal, including escaped characters.
(Note: doesn't yet handle escape sequences such as \123)
/"(\\\\.|.)\*?"/

Totality: total
surround : Lexer -> Lexer -> Lexer -> Lexer
  Recognise zero or more occurrences of a sub-lexer between
delimiting lexers
/`start`(`l`)\*?`end`/

Totality: total
symbol : Lexer
  Recognise a single non-whitespace, non-alphanumeric character
/[\^\\sA-Za-z0-9]/

Totality: total
symbols : Lexer
  Recognise one or more non-whitespace, non-alphanumeric characters
/[\^\\sA-Za-z0-9]+/

Totality: total
toTokenMap : List (Lexer, k) -> TokenMap (Tokenk)
Totality: total
upper : Lexer
  Recognise an uppercase alpha character
/[A-Z]/

Totality: total
uppers : Lexer
  Recognise one or more uppercase alpha characters
/[A-Z]+/

Totality: total