com.nexthink.utils.parsing.combinator.completion
AsyncCompletionSupport
Related Doc:
package completion
com.nexthink.utils.parsing.combinator.completion
A parser whose ~ combinator disallows back-tracking.
A parser generator that, roughly, generalises the rep1sep generator
so that q, which parses the separator, produces a left-associative
function that combines the elements it separates.
A parser generator that, roughly, generalises the rep1sep generator
so that q, which parses the separator, produces a left-associative
function that combines the elements it separates.
a parser that parses the first element
a parser that parses the subsequent elements
a parser that parses the token(s) separating the elements, yielding a left-associative function that combines two elements into one
A parser generator that, roughly, generalises the rep1sep generator so
that q, which parses the separator, produces a left-associative
function that combines the elements it separates.
A parser generator that, roughly, generalises the rep1sep generator so
that q, which parses the separator, produces a left-associative
function that combines the elements it separates.
From: J. Fokker. Functional parsers. In J. Jeuring and E. Meijer, editors, Advanced Functional Programming, volume 925 of Lecture Notes in Computer Science, pages 1--23. Springer, 1995.
a parser that parses the elements
a parser that parses the token(s) separating the elements, yielding a left-associative function that combines two elements into one
A parser generator that generalises the rep1sep generator so that q,
which parses the separator, produces a right-associative function that
combines the elements it separates.
A parser generator that generalises the rep1sep generator so that q,
which parses the separator, produces a right-associative function that
combines the elements it separates. Additionally, the right-most (last)
element and the left-most combining function have to be supplied.
rep1sep(p: Parser[T], q) corresponds to chainr1(p, q ^^ cons, cons, Nil) (where val cons = (x: T, y: List[T]) => x :: y)
a parser that parses the elements
a parser that parses the token(s) separating the elements, yielding a right-associative function that combines two elements into one
the "last" (left-most) combination function to be applied
the "first" (right-most) element to be combined
Wrap a parser so that its failures become errors (the | combinator
will give up as soon as it encounters an error, on failure it simply
tries the next alternative).
A parser generator for guard expressions.
A parser generator for guard expressions. The resulting parser will fail or succeed just like the one given as parameter but it will not consume any input.
a Parser that is to be applied to the input
A parser that returns success if and only if p succeeds but
never consumes any input
A helper method that turns a Parser into one that will
print debugging information to stdout before and after
being applied.
Wrap a parser so that its failures and errors become success and vice versa -- it never consumes any input.
A parser generator for optional sub-phrases.
A parser generator for optional sub-phrases.
opt(p) is a parser that returns Some(x) if p returns x and None if p fails.
A Parser that is tried on the input
a Parser that always succeeds: either with the result provided by p or
with the empty result
positioned decorates a parser's result with the start position of the
input it consumed.
positioned decorates a parser's result with the start position of the
input it consumed.
a Parser whose result conforms to Positional.
A parser that has the same behaviour as p, but which marks its
result with the start position of the input it consumed,
if it didn't already have a position.
A parser generator for repetitions.
A parser generator for repetitions.
rep(p) repeatedly uses p to parse the input until p fails
(the result is a List of the consecutive results of p).
a Parser that is to be applied successively to the input
A parser that returns a list of results produced by repeatedly applying p to the input.
A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1(f, p) first uses f (which must succeed) and then repeatedly
uses p to parse the input until p fails
(the result is a List of the consecutive results of f and p)
a Parser that parses the first piece of input
a Parser that is to be applied successively to the rest of the input (if any) -- evaluated at most once, and only when necessary
A parser that returns a list of results produced by first applying f and then
repeatedly p to the input (it only succeeds if f matches).
A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1(p) repeatedly uses p to parse the input until p fails -- p must succeed at least
once (the result is a List of the consecutive results of p)
a Parser that is to be applied successively to the input
A parser that returns a list of results produced by repeatedly applying p to the input
(and that only succeeds if p matches at least once).
(Changed in version 2.9.0) The p0 call-by-name arguments is evaluated at most once per constructed Parser object, instead of on every need that arises during parsing.
A parser generator for non-empty repetitions.
A parser generator for non-empty repetitions.
rep1sep(p, q) repeatedly applies p interleaved with q to parse the
input, until p fails. The parser p must succeed at least once.
a Parser that is to be applied successively to the input
a Parser that parses the elements that separate the elements parsed by p
(interleaved with q)
A parser that returns a list of results produced by repeatedly applying p to the input
(and that only succeeds if p matches at least once).
The results of p are collected in a list. The results of q are discarded.
A parser generator for a specified number of repetitions.
A parser generator for a specified number of repetitions.
repN(n, p) uses p exactly n time to parse the input
(the result is a List of the n consecutive results of p).
the exact number of times p must succeed
a Parser that is to be applied successively to the input
A parser that returns a list of results produced by repeatedly applying p to the input
(and that only succeeds if p matches exactly n times).
A parser generator for interleaved repetitions.
A parser generator for interleaved repetitions.
repsep(p, q) repeatedly uses p interleaved with q to parse the input, until p fails.
(The result is a List of the results of p.)
Example: repsep(term, ",") parses a comma-separated list of term's, yielding a list of these terms.
a Parser that is to be applied successively to the input
a Parser that parses the elements that separate the elements parsed by p
A parser that returns a list of results produced by repeatedly applying p (interleaved with q) to the input.
The results of p are collected in a list. The results of q are discarded.