cats-parse/cats.parse/Parser

Parser

sealed abstract class Parser[+A] extends Parser0[A]
Parser[A] is a Parser0[A] that will always consume one-or-more
characters on a successful parse.
Since Parser is guaranteed to consume input it provides additional
methods which would be unsafe when used on parsers that succeed
without consuming input, such as rep0.
When a Parser is composed with a Parser0 the result is usually a
Parser. Parser overrides many of Parser0's methods to refine the
return type. In other cases, callers may need to use the with1
helper method to refine the type of their expressions.
Parser doesn't provide any additional guarantees over Parser0 on
what kind of parsing failures it can return.
Companion
object
class Parser0[A]
class Object
trait Matchable
class Any

Value members

Methods

override def filter(fn: A => Boolean): Parser[A]
This method overrides Parser0#filter to refine the return type.
Definition Classes
override def void: Parser[Unit]
This method overrides Parser0#void to refine the return type.
Definition Classes
override def string: Parser[String]
This method overrides Parser0#string to refine the return type.
Definition Classes
override def backtrack: Parser[A]
This method overrides Parser0#backtrack to refine the return type.
Definition Classes
def eitherOr[B](pb: Parser[B]): Parser[Either[B, A]]
a version of eitherOr when both sides are not Parser0
override def ~[B](that: Parser0[B]): Parser[(A, B)]
This method overrides Parser0#~ to refine the return type.
Definition Classes
override def *>[B](that: Parser0[B]): Parser[B]
This method overrides Parser0#*> to refine the return type.
Definition Classes
override def <*[B](that: Parser0[B]): Parser[A]
This method overrides Parser0#<* to refine the return type.
Definition Classes
override def collect[B](fn: PartialFunction[A, B]): Parser[B]
This method overrides Parser0#collect to refine the return type.
Definition Classes
override def map[B](fn: A => B): Parser[B]
This method overrides Parser0#map to refine the return type.
Definition Classes
override def mapFilter[B](fn: A => Option[B]): Parser[B]
This method overrides Parser0#mapFilter to refine the return type.
Definition Classes
override def flatMap[B](fn: A => Parser0[B]): Parser[B]
This method overrides Parser0#flatMap to refine the return type.
Definition Classes
override def as[B](b: B): Parser[B]
This method overrides Parser0#as to refine the return type.
Definition Classes
def orElse[A1 >: A](that: Parser[A1]): Parser[A1]
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.
def |[A1 >: A](that: Parser[A1]): Parser[A1]
Synonym for orElse
def rep0: Parser0[List[A]]
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.
def rep0(min: Int): Parser0[List[A]]
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).
def rep0(min: Int, max: Int): Parser0[List[A]]
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
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def rep: Parser[NonEmptyList[A]]
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.
def rep(min: Int): Parser[NonEmptyList[A]]
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.
def rep(min: Int, max: Int): Parser[NonEmptyList[A]]
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
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repAs0[B](acc: Accumulator0[A, B]): Parser0[B]
Repeat the parser 0 or more times
Note
this can wind up parsing nothing
def repAs0[B](max: Int)(acc: Accumulator0[A, B]): Parser0[B]
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
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
Note
this can wind up parsing nothing
def repAs[B](acc: Accumulator[A, B]): Parser[B]
Repeat the parser 1 or more times
def repAs[B](min: Int)(acc: Accumulator[A, B]): Parser[B]
Repeat the parser min or more times
The parser fails if it can't match at least min times
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repAs[B](min: Int, max: Int)(acc: Accumulator[A, B]): Parser[B]
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
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repExactlyAs[B](times: Int)(acc: Accumulator[A, B]): Parser[B]
Repeat the parser exactly times times
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repSep0(sep: Parser0[Any]): Parser0[List[A]]
Repeat 0 or more times with a separator
def repSep0(min: Int, sep: Parser0[Any]): Parser0[List[A]]
Repeat min or more times with a separator.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repSep0(min: Int, max: Int, sep: Parser0[Any]): Parser0[List[A]]
Repeat min or more, up to max times with a separator.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repSep(sep: Parser0[Any]): Parser[NonEmptyList[A]]
Repeat 1 or more times with a separator
def repSep(min: Int, sep: Parser0[Any]): Parser[NonEmptyList[A]]
Repeat min or more times with a separator, at least once.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repSep(min: Int, max: Int, sep: Parser0[Any]): Parser[NonEmptyList[A]]
Repeat min or more, up to max times with a separator, at least once.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repUntil0(end: Parser0[Any]): Parser0[List[A]]
Repeat this parser 0 or more times until end Parser succeeds.
def repUntil(end: Parser0[Any]): Parser[NonEmptyList[A]]
Repeat this parser 1 or more times until end Parser succeeds.
def repUntilAs0[B](end: Parser0[Any])(acc: Accumulator0[A, B]): Parser0[B]
Repeat this parser 0 or more times until end Parser succeeds.
def repUntilAs[B](end: Parser0[Any])(acc: Accumulator[A, B]): Parser[B]
Repeat this parser 1 or more times until end Parser succeeds.
override def between(b: Parser0[Any], c: Parser0[Any]): Parser[A]
This method overrides Parser0#between to refine the return type
Definition Classes
override def surroundedBy(b: Parser0[Any]): Parser[A]
This method overrides Parser0#surroundedBy to refine the return type
Definition Classes
override def soft: Soft[A]
This method overrides Parser0#soft to refine the return type.
Definition Classes

Inherited methods

def unary_!: Parser0[Unit]
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.
Inhertied from
Parser0
def peek: Parser0[Unit]
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.
Inhertied from
Parser0
def |[A1 >: A](that: Parser0[A1]): Parser0[A1]
Synonym for orElse
Inhertied from
Parser0
final def parseAll(str: String): Either[Error, A]
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).
Inhertied from
Parser0
def with1: With1[A]
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.
Inhertied from
Parser0
def orElse[A1 >: A](that: Parser0[A1]): Parser0[A1]
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.
Inhertied from
Parser0
def eitherOr[B](pb: Parser0[B]): Parser0[Either[B, A]]
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.
Inhertied from
Parser0
final def parse(str: String): Either[Error, (String, A)]
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.
Inhertied from
Parser0
def ?: Parser0[Option[A]]
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.
Inhertied from
Parser0