Scanners

Scanner is essentially¹ a parser that produces Tokens from a stream of characters. The tokens it produces are typically passed to parsers in TokenParsers.

The fatal failure case of ParseResult: contains an error-message and the remaining input. No back-tracking is done when a parser returns an Error.

The failure case of ParseResult: contains an error-message and the remaining input. Parsing will back-track when a failure occurs.

A common super-class for unsuccessful parse results.

An extractor so NoSuccess(msg, next) can be used in matches.

A parser whose ~ combinator disallows back-tracking.

A base class for parser results. A result is either successful or not (failure may be fatal, i.e., an Error, or not, i.e., a Failure). On success, provides a result of type T which consists of some result (and the rest of the input).

The root class of parsers. Parsers are functions from the Input type to ParseResult.

The success case of ParseResult: contains the result and the remaining input.

A wrapper over sequence of matches.

Given p1: Parser[A] and p2: Parser[B], a parser composed with p1 ~ p2 will have type Parser[~[A, B]]. The successful result of the parser can be extracted from this case class.

It also enables pattern matching, so something like this is possible:

def concat(p1: Parser[String], p2: Parser[String]): Parser[String] =
  p1 ~ p2 ^^ { case a ~ b => a + b }

The parser input is an abstract reader of input elements, i.e. the type of input the parsers in this component expect.

This token is produced by a scanner Scanner when scanning failed.

A parser that produces a token (from a stream of characters).

A parser for white-space -- its result will be discarded.

The parser that matches an element in the domain of the partial function f.

If f is defined on the first element in the input, f is applied to it to produce this parser's result.

Example: The parser accept("name", {case Identifier(n) => Name(n)}) accepts an Identifier(n) and returns a Name(n)

A parser that matches only the given list of element es.

accept(es) succeeds if the input subsequently provides the elements in the list es.

A parser matching input elements that satisfy a given predicate.

acceptIf(p)(el => "Unexpected "+el) succeeds if the input starts with an element e for which p(e) is true.

The parser that matches an element in the domain of the partial function f.

If f is defined on the first element in the input, f is applied to it to produce this parser's result.

Example: The parser acceptMatch("name", {case Identifier(n) => Name(n)}) accepts an Identifier(n) and returns a Name(n)

A parser that matches only the given scala.collection.Iterable collection of elements es.

acceptSeq(es) succeeds if the input subsequently provides the elements in the iterable es.

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 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)

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 that matches only the given element e.

elem(e) succeeds if the input starts with an element e.

A parser matching input elements that satisfy a given predicate.

elem(kind, p) succeeds if the input starts with an element e for which p(e) is true.

A parser that results in an error.

A parser that always fails.

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 helper method that turns a Parser into one that will print debugging information to stdout before and after being applied.

Given a concatenation with a repetition (list), move the concatenated element into the list

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.

opt(p) is a parser that returns Some(x) if p returns x and None if p fails.

A parser generator delimiting whole phrases (i.e. programs).

phrase(p) succeeds if p succeeds and no input is left over after p.

positioned decorates a parser's result with the start position of the input it consumed.

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 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 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 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 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).

A parser generator for a specified range of repetitions interleaved by a separator.

repNM(n, m, p, s) uses p at least n times and up to m times, interleaved with separator s, to parse the input (the result is a List of at least n consecutive results of p and up to m results).

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 always succeeds.

A parser that matches only the given element e.

The method is implicit so that elements can automatically be lifted to their parsers. For example, when parsing Tokens, Identifier("new") (which is a Token) can be used directly, instead of first creating a Parser using accept(Identifier("new")).