Module combine::combinator

Module containing all specific parsers

Structs

And
AndThen
Any
Between
Chainl1
Chainr1
Choice
EnvParser
Expected
FnParser
Iter
LookAhead
Many
Many1
Map
Message
NotFollowedBy
Optional
Or
Satisfy
SepBy
SepBy1
SepEndBy
SepEndBy1
Skip
SkipMany
SkipMany1
Then
Token
Try
Unexpected
Value
With

Traits

ParserExt

Extension trait which provides functions that are more conveniently used through method calls

Functions

any	Parses any token
between	Parses open followed by parser followed by close Returns the value of parser
chainl1	Parses p 1 or more times separated by op The value returned is the one produced by the left associative application of op
chainr1	Parses p one or more times separated by op The value returned is the one produced by the right associative application of op
choice	Takes an array of parsers and tries to apply them each in order. Fails if all parsers fails or if an applied parser consumes input before failing.
env_parser	Constructs a parser out of an environment and a function which needs the given environment to do the parsing. This is commonly useful to allow multiple parsers to share some environment while still allowing the parsers to be written in separate functions.
look_ahead	look_ahead acts as p but doesn't consume input on success.
many	Parses p zero or more times returning a collection with the values from p. If the returned collection cannot be inferred type annotations must be supplied, either by annotating the resulting type binding let collection: Vec<_> = ... or by specializing when calling many, many::<Vec<_>, _>(...)
many1	Parses p one or more times returning a collection with the values from p. If the returned collection cannot be inferred type annotations must be supplied, either by annotating the resulting type binding let collection: Vec<_> = ... or by specializing when calling many1 many1::<Vec<_>, _>(...)
not_followed_by	Succeeds only if parser fails. Never consumes any input.
optional	Returns Some(value) and None on parse failure (always succeeds)
parser	Wraps a function, turning it into a parser Mainly needed to turn closures into parsers as function types can be casted to function pointers to make them usable as a parser
satisfy	Parses a token and succeeds depending on the result of predicate
sep_by	Parses parser zero or more time separated by separator, returning a collection with the values from p. If the returned collection cannot be inferred type annotations must be supplied, either by annotating the resulting type binding let collection: Vec<_> = ... or by specializing when calling sep_by, sep_by::<Vec<_>, _, _>(...)
sep_by1	Parses parser one or more time separated by separator, returning a collection with the values from p. If the returned collection cannot be inferred type annotations must be supplied, either by annotating the resulting type binding let collection: Vec<_> = ... or by specializing when calling sep_by, sep_by1::<Vec<_>, _, _>(...)
sep_end_by	Parses parser zero or more time separated by separator, returning a collection with the values from p. If the returned collection cannot be inferred type annotations must be supplied, either by annotating the resulting type binding let collection: Vec<_> = ... or by specializing when calling sep_by, sep_by::<Vec<_>, _, _>(...)
sep_end_by1	Parses parser one or more time separated by separator, returning a collection with the values from p. If the returned collection cannot be inferred type annotations must be supplied, either by annotating the resulting type binding let collection: Vec<_> = ... or by specializing when calling sep_by, sep_by1::<Vec<_>, _, _>(...)
skip_many	Parses p zero or more times ignoring the result
skip_many1	Parses p one or more times ignoring the result
token	Parses a character and succeeds if the character is equal to c
try	Try acts as p except it acts as if the parser hadn't consumed any input if p returns an error after consuming input
unexpected	Always fails with message as an unexpected error. Never consumes any input.
value	Always returns the value v without consuming any input.