Parser

This method overrides Parser0#*> to refine the return type.

This method overrides Parser0#<* to refine the return type.

This method overrides Parser0#as to refine the return type.

This method overrides Parser0#backtrack to refine the return type.

This method overrides Parser0#between to refine the return type

This method overrides Parser0#collect to refine the return type.

a version of eitherOr when both sides are not Parser0

This method overrides Parser0#filter to refine the return type.

This method overrides Parser0#flatMap to refine the return type.

This method overrides Parser0#map to refine the return type.

This method overrides Parser0#mapFilter to refine the return type.

If this parser fails to parse its input with an epsilon error, try the given parser instead.

This method is similar to Parser0#orElse, but since both arguments are known to be Parser values, the result is known to be a Parser as well.

Use this parser to parse one-or-more values.

This parser behaves like rep0, except that it must produce at least one value, and is guaranteed to consume input on successful parses.

Use this parser to parse at least min values (where min >= 1).

This method behaves likes rep, except that if fewer than min values are produced an arresting failure will be returned.

Repeat the parser min or more times, but no more than max

The parser fails if it can't match at least min times After repeating the parser max times, the parser completes successfully

Use this parser to parse zero-or-more values.

This parser may succeed without consuming input in the case where zero values are parsed.

If the underlying parser hits an arresting failure, the entire parse is also an arresting failure. If the underlying parser hits an epsilon failure, the parsed values (if any) are returned in a list as a successful parse.

Use this parser to parse at least min values (where min >= 0).

If min is zero, this parser may succeed without consuming input in the case where zero values are parsed. If min is known to be greater than zero, consider using rep(min) instead.

Like rep0, arresting failures in the underlying parser will result in an arresting failure. Unlike rep0, this method may also return an arresting failure if it has not parsed at least min values (but has consumed input).

Repeat the parser min or more times, but no more than max

The parser fails if it can't match at least min times After repeating the parser max times, the parser completes successfully

Repeat the parser 1 or more times

Repeat the parser min or more times

The parser fails if it can't match at least min times

Repeat the parser min or more times, but no more than max

The parser fails if it can't match at least min times After repeating the parser max times, the parser completes successfully

Repeat the parser 0 or more times

Repeat the parser 0 or more times, but no more than max

It may seem weird to accept 0 here, but without, composing this method becomes more complex. Since and empty parse is possible for this method, we do allow max = 0

Repeat the parser exactly times times

Repeat 1 or more times with a separator

Repeat min or more times with a separator, at least once.

Repeat min or more, up to max times with a separator, at least once.

Repeat 0 or more times with a separator

Repeat min or more times with a separator.

Repeat min or more, up to max times with a separator.

Repeat this parser 1 or more times until end Parser succeeds.

Repeat this parser 0 or more times until end Parser succeeds.

Repeat this parser 1 or more times until end Parser succeeds.

Repeat this parser 0 or more times until end Parser succeeds.

This method overrides Parser0#soft to refine the return type.

This method overrides Parser0#string to refine the return type.

This method overrides Parser0#surroundedBy to refine the return type

This method overrides Parser0#void to refine the return type.

This method overrides Parser0#withContext to refine the return type. add a string context to any Errors on parsing this is useful for debugging failing parsers.

Synonym for orElse Note this is not commutative: if this has an arresting failure we do not continue onto the next.

This method overrides Parser0#~ to refine the return type.

Convert epsilon failures into None values.

Normally if a parser fails to consume any input it fails with an epsilon failure. The ? method converts these failures into None values (and wraps other values in Some(_)).

If the underlying parser failed with other errors, this parser will still fail.

If this parser fails to parse its input with an epsilon error, try the given parser instead.

If this parser fails with an arresting error, the next parser won't be tried.

Backtracking may be used on the left parser to allow the right one to pick up after any error, resetting any state that was modified by the left parser.

This method is similar to Parser#orElse but returns Either.

If this parser fails to parse its input with an epsilon error, try the given parser instead.

If this parser fails with an arresting error, the next parser won't be tried.

Backtracking may be used on the left parser to allow the right one to pick up after any error, resetting any state that was modified by the left parser.

Attempt to parse an A value out of str.

This method will either return a failure, or else the remaining string and the parsed value.

To require the entire input to be consumed, see parseAll.

Attempt to parse all of the input str into an A value.

This method will return a failure unless all of str is consumed during parsing.

p.parseAll(s) is equivalent to (p <* Parser.end).parse(s).map(_._2).

Return a parser that succeeds (consuming nothing and extracting nothing) if the current parser would also succeed.

This parser expects the underlying parser to succeed, and will unconditionally backtrack after running it.

Return a parser that succeeds (consuming nothing, and extracting nothing) if the current parser would fail.

This parser expects the underlying parser to fail, and will unconditionally backtrack after running it.

Wrap this parser in a helper class, enabling better composition with Parser values.

For example, with p: Parser0[Int] and p1: Parser0[Double]:

val a1: Parser0[(Int, Double)] = p ~ p1 val a2: Parser[(Int, Double)] = p.with1 ~ p1

val b1: Parser0[Double] = p *> p1 val b2: Parser[Double] = p.with1 *> p1

val c1: Parser0[Int] = p <* p1 val c2: Parser[Int] = p.with1 <* p1

Without using with1, these methods will return Parser0 values since they are not known to return Parser values instead.

Synonym for orElse Note this is not commutative: if this has an arresting failure we do not continue onto the next.

This method overrides Object#hashCode to cache its result for performance reasons.