Parser

Type Members

final case class Error(failedAtOffset: Int, expected: NonEmptyList[Expectation]) extends Product with Serializable

Represents where a failure occurred and all the expectations that were broken
sealed abstract class Expectation extends AnyRef

An expectation reports the kind or parsing error and where it occured.
final class Soft[+A] extends Soft0[A]

If we can parse this then that, do so, if we fail that without consuming, rewind before this without consuming.
If we can parse this then that, do so, if we fail that without consuming, rewind before this without consuming. If either consume 1 or more, do not rewind
sealed class Soft0[+A] extends AnyRef

If we can parse this then that, do so, if we fail that without consuming, rewind before this without consuming.
If we can parse this then that, do so, if we fail that without consuming, rewind before this without consuming. If either consume 1 or more, do not rewind
final class Soft01[+A] extends AnyVal

If we can parse this then that, do so, if we fail that without consuming, rewind before this without consuming.
If we can parse this then that, do so, if we fail that without consuming, rewind before this without consuming. If either consume 1 or more, do not rewind
final class State extends AnyRef

Attributes
protected[cats.parse]
final class With1[+A] extends AnyVal

Enables syntax to access product01, product and flatMap01 This helps us build Parser instances when starting from a Parser0

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
object Expectation
val Fail: Parser[Nothing]

A parser that always fails with an epsilon failure
def anyChar: Parser[Char]

Parse 1 character from the string
def as[B](pa: Parser[Any], b: B): Parser[B]

Replaces parsed values with the given value.
def as0[B](pa: Parser0[Any], b: B): Parser0[B]

Replaces parsed values with the given value.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def backtrack[A](pa: Parser[A]): Parser[A]

If we fail, rewind the offset back so that we can try other branches.
If we fail, rewind the offset back so that we can try other branches. This tends to harm debuggability and ideally should be minimized
def backtrack0[A](pa: Parser0[A]): Parser0[A]

If we fail, rewind the offset back so that we can try other branches.
If we fail, rewind the offset back so that we can try other branches. This tends to harm debuggability and ideally should be minimized
def caret: Parser0[Caret]

return the current Caret (offset, line, column) this is a bit more expensive that just the index
implicit val catsInstancesParser: FlatMap[Parser] with Defer[Parser] with MonoidK[Parser] with FunctorFilter[Parser]
def char(c: Char): Parser[Unit]

parse a single character
def charIn(c0: Char, cs: Char*): Parser[Char]

parse one of a given set of characters
def charIn(cs: Iterable[Char]): Parser[Char]

An empty iterable is the same as fail
def charWhere(fn: (Char) ⇒ Boolean): Parser[Char]

parse one character that matches a given function
def charsWhile(fn: (Char) ⇒ Boolean): Parser[String]

Parse a string while the given function is true parses at least one character
def charsWhile0(fn: (Char) ⇒ Boolean): Parser0[String]

Parse a string while the given function is true
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def defer[A](pa: ⇒ Parser[A]): Parser[A]

Lazily create a Parser This is useful to create some recursive parsers see Defer0[Parser].fix
def defer0[A](pa: ⇒ Parser0[A]): Parser0[A]

Lazily create a Parser0 This is useful to create some recursive parsers see Defer0[Parser].fix
def eitherOr[A, B](first: Parser[B], second: Parser[A]): Parser[Either[A, B]]

If the first parser fails to parse its input with an epsilon error, try the second parser instead.
If the first parser fails to parse its input with an epsilon error, try the second parser instead.
If the first parser fails with an arresting error, the second parser won't be tried.
Backtracking may be used on the first parser to allow the second one to pick up after any error, resetting any state that was modified by the first parser.
def eitherOr0[A, B](first: Parser0[B], second: Parser0[A]): Parser0[Either[A, B]]

If the first parser fails to parse its input with an epsilon error, try the second parser instead.
If the first parser fails to parse its input with an epsilon error, try the second parser instead.
If the first parser fails with an arresting error, the second parser won't be tried.
Backtracking may be used on the first parser to allow the second one to pick up after any error, resetting any state that was modified by the first parser.
def end: Parser0[Unit]

succeeds when we are at the end
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def fail[A]: Parser[A]

A parser that always fails with an epsilon failure
def failWith[A](message: String): Parser[A]

A parser that always fails with an epsilon failure and a given message this is generally used with flatMap to validate a result beyond the literal parsing.
A parser that always fails with an epsilon failure and a given message this is generally used with flatMap to validate a result beyond the literal parsing.
e.g. parsing a number then validate that it is bounded.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flatMap0[A, B](pa: Parser0[A])(fn: (A) ⇒ Parser0[B]): Parser0[B]

Standard monadic flatMap Avoid this function if possible.
Standard monadic flatMap Avoid this function if possible. If you can instead use product, ~, *>, or <* use that. flatMap always has to allocate a parser, and the parser is less amenable to optimization
def flatMap01[A, B](pa: Parser0[A])(fn: (A) ⇒ Parser[B]): Parser[B]

Standard monadic flatMap where you end with a Parser Avoid this function if possible.
Standard monadic flatMap where you end with a Parser Avoid this function if possible. If you can instead use product, ~, *>, or <* use that. flatMap always has to allocate a parser, and the parser is less amenable to optimization
def flatMap10[A, B](pa: Parser[A])(fn: (A) ⇒ Parser0[B]): Parser[B]

Standard monadic flatMap where you start with a Parser Avoid this function if possible.
Standard monadic flatMap where you start with a Parser Avoid this function if possible. If you can instead use product, ~, *>, or <* use that. flatMap always has to allocate a parser, and the parser is less amenable to optimization
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def ignoreCase(str: String): Parser[Unit]

Parse a given string, in a case-insensitive manner, or fail.
Parse a given string, in a case-insensitive manner, or fail. This backtracks on failure this is an error if the string is empty
def ignoreCase0(str: String): Parser0[Unit]

Parse a potentially empty string, in a case-insensitive manner, or fail.
Parse a potentially empty string, in a case-insensitive manner, or fail. This backtracks on failure
def ignoreCaseChar(c: Char): Parser[Unit]

Ignore the case of a single character If you want to know if it is upper or lower, use .string to capture the string and then map to process the result.
def ignoreCaseCharIn(c0: Char, cs: Char*): Parser[Char]

Parse any single character in a set of characters as lower or upper case
def ignoreCaseCharIn(cs: Iterable[Char]): Parser[Char]

Parse any single character in a set of characters as lower or upper case
def index: Parser0[Int]

return the current position in the string we are parsing.
return the current position in the string we are parsing. This lets you record position information in your ASTs you are parsing
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def length(len: Int): Parser[String]

Parse the next len characters where len > 0 if (len < 1) throw IllegalArgumentException
def length0(len: Int): Parser0[String]

if len < 1, the same as pure("") else length(len)
def map[A, B](p: Parser[A])(fn: (A) ⇒ B): Parser[B]

transform a Parser result
def map0[A, B](p: Parser0[A])(fn: (A) ⇒ B): Parser0[B]

transform a Parser0 result
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def not(pa: Parser0[Any]): Parser0[Unit]

returns a parser that succeeds if the current parser fails.
returns a parser that succeeds if the current parser fails. Note, this parser backtracks (never returns an arresting failure)
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def oneOf[A](parsers: List[Parser[A]]): Parser[A]

go through the list of parsers trying each as long as they are epsilon failures (don't advance) see @backtrack if you want to do backtracking.
go through the list of parsers trying each as long as they are epsilon failures (don't advance) see @backtrack if you want to do backtracking.
This is the same as parsers.foldLeft(fail)(_.orElse(_))
recommended style: oneOf(p1 :: p2 :: p3 :: Nil) rather than oneOf(List(p1, p2, p3))
Note: order matters here, since we don't backtrack by default.
def oneOf0[A](ps: List[Parser0[A]]): Parser0[A]

go through the list of parsers trying each as long as they are epsilon failures (don't advance) see @backtrack if you want to do backtracking.
go through the list of parsers trying each as long as they are epsilon failures (don't advance) see @backtrack if you want to do backtracking.
This is the same as parsers.foldLeft(fail)(_.orElse(_))
recommended style: oneOf(p1 :: p2 :: p3 :: Nil) rather than oneOf(List(p1, p2, p3))
Note: order matters here, since we don't backtrack by default.
def peek(pa: Parser0[Any]): Parser0[Unit]

a parser that consumes nothing when it succeeds, basically rewind on success
def product0[A, B](first: Parser0[A], second: Parser0[B]): Parser0[(A, B)]

parse first then second
def product01[A, B](first: Parser0[A], second: Parser[B]): Parser[(A, B)]

product with the second argument being a Parser
def product10[A, B](first: Parser[A], second: Parser0[B]): Parser[(A, B)]

product with the first argument being a Parser
def pure[A](a: A): Parser0[A]

Don't advance in the parsed string, just return a This is used by the Applicative typeclass.
def recursive[A](fn: (Parser[A]) ⇒ Parser[A]): Parser[A]

Build a recursive parser by assuming you have it Useful for parsing recurive structures, like for instance JSON.
def repAs[A, B](p1: Parser[A], min: Int, max: Int)(implicit acc: Accumulator[A, B]): Parser[B]

Repeat the parser min or more times, but no more than max
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 succesfully

Exceptions thrown
java.lang.IllegalArgumentException if min < 1 or max < min
def repAs[A, B](p1: Parser[A], min: Int)(implicit acc: Accumulator[A, B]): Parser[B]

Repeat the parser min or more times
Repeat the parser min or more times
The parser fails if it can't match at least min times

Exceptions thrown
java.lang.IllegalArgumentException if min < 1
def repAs0[A, B](p1: Parser[A], max: Int)(implicit acc: Accumulator0[A, B]): Parser0[B]

Repeat the parser 0 or more times, but no more than max
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

Exceptions thrown
java.lang.IllegalArgumentException if max < 0
Note
this can wind up parsing nothing
def repAs0[A, B](p1: Parser[A])(implicit acc: Accumulator0[A, B]): Parser0[B]

Repeat the parser 0 or more times
Repeat the parser 0 or more times

Note
this can wind up parsing nothing
def repExactlyAs[A, B](p: Parser[A], times: Int)(implicit acc: Accumulator[A, B]): Parser[B]

Repeat the parser exactly times times
Repeat the parser exactly times times

Exceptions thrown
java.lang.IllegalArgumentException if times < 1
def repSep[A](p1: Parser[A], min: Int, max: Int, sep: Parser0[Any]): Parser[NonEmptyList[A]]

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

Exceptions thrown
java.lang.IllegalArgumentException if min <= 0 or max < min
def repSep[A](p1: Parser[A], min: Int, sep: Parser0[Any]): Parser[NonEmptyList[A]]

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

Exceptions thrown
java.lang.IllegalArgumentException if min <= 0
def repSep[A](p1: Parser[A], sep: Parser0[Any]): Parser[NonEmptyList[A]]

Repeat 1 or more times with a separator
def repSep0[A](p1: Parser[A], min: Int, max: Int, sep: Parser0[Any]): Parser0[List[A]]

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

Exceptions thrown
java.lang.IllegalArgumentException if min < 0 or max < min
def repSep0[A](p1: Parser[A], min: Int, sep: Parser0[Any]): Parser0[List[A]]

Repeat min or more times with a separator.
Repeat min or more times with a separator.

Exceptions thrown
java.lang.IllegalArgumentException if min < 0
def repSep0[A](p1: Parser[A], sep: Parser0[Any]): Parser0[List[A]]

Repeat 0 or more times with a separator
def repUntil[A](p: Parser[A], end: Parser0[Any]): Parser[NonEmptyList[A]]

parse one or more times until Parser end succeeds.
def repUntil0[A](p: Parser[A], end: Parser0[Any]): Parser0[List[A]]

parse zero or more times until Parser end succeeds.
def repUntilAs[A, B](p: Parser[A], end: Parser0[Any])(implicit acc: Accumulator[A, B]): Parser[B]

parse one or more times until Parser end succeeds.
def repUntilAs0[A, B](p: Parser[A], end: Parser0[Any])(implicit acc: Accumulator0[A, B]): Parser0[B]

parse zero or more times until Parser end succeeds.
def select[A, B](p: Parser[Either[A, B]])(fn: Parser0[(A) ⇒ B]): Parser[B]

Parser version of select
def select0[A, B](p: Parser0[Either[A, B]])(fn: Parser0[(A) ⇒ B]): Parser0[B]

Parse p and if we get the Left side, parse fn This function name comes from seletive functors.
Parse p and if we get the Left side, parse fn This function name comes from seletive functors. This should be more efficient than flatMap since the fn Parser0 is evaluated once, not on every item parsed
def softProduct0[A, B](first: Parser0[A], second: Parser0[B]): Parser0[(A, B)]

softProduct, a variant of product A soft product backtracks if the first succeeds and the second is an epsilon-failure.
softProduct, a variant of product A soft product backtracks if the first succeeds and the second is an epsilon-failure. By contrast product will be a failure in that case
see @Parser.soft
def softProduct01[A, B](first: Parser0[A], second: Parser[B]): Parser[(A, B)]

softProduct with the second argument being a Parser A soft product backtracks if the first succeeds and the second is an epsilon-failure.
softProduct with the second argument being a Parser A soft product backtracks if the first succeeds and the second is an epsilon-failure. By contrast product will be a failure in that case
see @Parser.soft
def softProduct10[A, B](first: Parser[A], second: Parser0[B]): Parser[(A, B)]

softProduct with the first argument being a Parser A soft product backtracks if the first succeeds and the second is an epsilon-failure.
softProduct with the first argument being a Parser A soft product backtracks if the first succeeds and the second is an epsilon-failure. By contrast product will be a failure in that case
see @Parser.soft
def start: Parser0[Unit]

succeeds when we are at the start
def string(pa: Parser[Any]): Parser[String]

Discard the result A and instead capture the matching string this is optimized to avoid internal allocations
def string(str: String): Parser[Unit]

Parse a given string or fail.
Parse a given string or fail. This backtracks on failure this is an error if the string is empty
def string0(pa: Parser0[Any]): Parser0[String]

Discard the result A and instead capture the matching string this is optimized to avoid internal allocations
def string0(str: String): Parser0[Unit]

Parse a potentially empty string or fail.
Parse a potentially empty string or fail. This backtracks on failure
def stringIn(strings: Iterable[String]): Parser[String]

Parse the longest matching string between alternatives.
Parse the longest matching string between alternatives. The order of the strings does not matter.
If no string matches, this parser results in an epsilon failure.
It is an error to pass the empty string here, if you need that see stringIn0
def stringIn0(strings: Iterable[String]): Parser0[String]

Version of stringIn that allows the empty string
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tailRecM[A, B](init: A)(fn: (A) ⇒ Parser[Either[A, B]]): Parser[B]

tail recursive monadic flatMaps on Parser This is a rarely used function, but needed to implement cats.FlatMap Avoid this function if possible.
tail recursive monadic flatMaps on Parser This is a rarely used function, but needed to implement cats.FlatMap Avoid this function if possible. If you can instead use product, ~, *>, or <* use that. flatMap always has to allocate a parser, and the parser is less amenable to optimization
def tailRecM0[A, B](init: A)(fn: (A) ⇒ Parser0[Either[A, B]]): Parser0[B]

tail recursive monadic flatMaps This is a rarely used function, but needed to implement cats.FlatMap Avoid this function if possible.
tail recursive monadic flatMaps This is a rarely used function, but needed to implement cats.FlatMap Avoid this function if possible. If you can instead use product, ~, *>, or <* use that. flatMap always has to allocate a parser, and the parser is less amenable to optimization
def toString(): String

Definition Classes
AnyRef → Any
val unit: Parser0[Unit]

A parser that returns unit
def until(p: Parser0[Any]): Parser[String]

parse one or more characters as long as they don't match p
def until0(p: Parser0[Any]): Parser0[String]

parse zero or more characters as long as they don't match p this is useful for parsing comment strings, for instance.
def void(pa: Parser[Any]): Parser[Unit]

discard the value in a Parser.
discard the value in a Parser. This is an optimization because we remove trailing map operations and don't allocate internal data structures This function is called internal to Functor.as and Apply.*> and Apply.<* so those are good uses.
def void0(pa: Parser0[Any]): Parser0[Unit]

discard the value in a Parser.
discard the value in a Parser. This is an optimization because we remove trailing map operations and don't allocate internal data structures This function is called internal to Functor.as and Apply.*> and Apply.<* so those are good uses.
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withContext[A](p: Parser[A], ctx: String): Parser[A]

Add a context string to Errors to aid debugging
def withContext0[A](p0: Parser0[A], ctx: String): Parser0[A]

Add a context string to Errors to aid debugging

Related Docs: class Parser | package parse

object Parser

Type Members

final case class Error(failedAtOffset: Int, expected: NonEmptyList[Expectation]) extends Product with Serializable

sealed abstract class Expectation extends AnyRef

final class Soft[+A] extends Soft0[A]

sealed class Soft0[+A] extends AnyRef

final class Soft01[+A] extends AnyVal

final class State extends AnyRef

final class With1[+A] extends AnyVal

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Expectation

val Fail: Parser[Nothing]

def anyChar: Parser[Char]

def as[B](pa: Parser[Any], b: B): Parser[B]

def as0[B](pa: Parser0[Any], b: B): Parser0[B]

final def asInstanceOf[T0]: T0

def backtrack[A](pa: Parser[A]): Parser[A]

def backtrack0[A](pa: Parser0[A]): Parser0[A]

def caret: Parser0[Caret]

implicit val catsInstancesParser: FlatMap[Parser] with Defer[Parser] with MonoidK[Parser] with FunctorFilter[Parser]

def char(c: Char): Parser[Unit]

def charIn(c0: Char, cs: Char*): Parser[Char]

def charIn(cs: Iterable[Char]): Parser[Char]

def charWhere(fn: (Char) ⇒ Boolean): Parser[Char]

def charsWhile(fn: (Char) ⇒ Boolean): Parser[String]

def charsWhile0(fn: (Char) ⇒ Boolean): Parser0[String]

def clone(): AnyRef

def defer[A](pa: ⇒ Parser[A]): Parser[A]

def defer0[A](pa: ⇒ Parser0[A]): Parser0[A]

def eitherOr[A, B](first: Parser[B], second: Parser[A]): Parser[Either[A, B]]

def eitherOr0[A, B](first: Parser0[B], second: Parser0[A]): Parser0[Either[A, B]]

def end: Parser0[Unit]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def fail[A]: Parser[A]

def failWith[A](message: String): Parser[A]

def finalize(): Unit

def flatMap0[A, B](pa: Parser0[A])(fn: (A) ⇒ Parser0[B]): Parser0[B]

def flatMap01[A, B](pa: Parser0[A])(fn: (A) ⇒ Parser[B]): Parser[B]

def flatMap10[A, B](pa: Parser[A])(fn: (A) ⇒ Parser0[B]): Parser[B]

final def getClass(): Class[_]

def hashCode(): Int

def ignoreCase(str: String): Parser[Unit]

def ignoreCase0(str: String): Parser0[Unit]

def ignoreCaseChar(c: Char): Parser[Unit]

def ignoreCaseCharIn(c0: Char, cs: Char*): Parser[Char]

def ignoreCaseCharIn(cs: Iterable[Char]): Parser[Char]

def index: Parser0[Int]

final def isInstanceOf[T0]: Boolean

def length(len: Int): Parser[String]

def length0(len: Int): Parser0[String]

def map[A, B](p: Parser[A])(fn: (A) ⇒ B): Parser[B]

def map0[A, B](p: Parser0[A])(fn: (A) ⇒ B): Parser0[B]

final def ne(arg0: AnyRef): Boolean

def not(pa: Parser0[Any]): Parser0[Unit]

final def notify(): Unit

final def notifyAll(): Unit

def oneOf[A](parsers: List[Parser[A]]): Parser[A]

def oneOf0[A](ps: List[Parser0[A]]): Parser0[A]

def peek(pa: Parser0[Any]): Parser0[Unit]

def product0[A, B](first: Parser0[A], second: Parser0[B]): Parser0[(A, B)]

def product01[A, B](first: Parser0[A], second: Parser[B]): Parser[(A, B)]

def product10[A, B](first: Parser[A], second: Parser0[B]): Parser[(A, B)]

def pure[A](a: A): Parser0[A]

def recursive[A](fn: (Parser[A]) ⇒ Parser[A]): Parser[A]

def repAs[A, B](p1: Parser[A], min: Int, max: Int)(implicit acc: Accumulator[A, B]): Parser[B]

def repAs[A, B](p1: Parser[A], min: Int)(implicit acc: Accumulator[A, B]): Parser[B]

def repAs0[A, B](p1: Parser[A], max: Int)(implicit acc: Accumulator0[A, B]): Parser0[B]

def repAs0[A, B](p1: Parser[A])(implicit acc: Accumulator0[A, B]): Parser0[B]

def repExactlyAs[A, B](p: Parser[A], times: Int)(implicit acc: Accumulator[A, B]): Parser[B]

def repSep[A](p1: Parser[A], min: Int, max: Int, sep: Parser0[Any]): Parser[NonEmptyList[A]]

def repSep[A](p1: Parser[A], min: Int, sep: Parser0[Any]): Parser[NonEmptyList[A]]

def repSep[A](p1: Parser[A], sep: Parser0[Any]): Parser[NonEmptyList[A]]

def repSep0[A](p1: Parser[A], min: Int, max: Int, sep: Parser0[Any]): Parser0[List[A]]

def repSep0[A](p1: Parser[A], min: Int, sep: Parser0[Any]): Parser0[List[A]]