cats-parse/cats.parse/Parser$

Parser

object Parser
Companion
class
trait Sum
trait Mirror
class Object
trait Matchable
class Any

Type members

Classlikes

sealed abstract class Expectation
An expectation reports the kind or parsing error
and where it occured.
Companion
object
object Expectation
Companion
class
final case class Error(failedAtOffset: Int, expected: NonEmptyList[Expectation])
Represents where a failure occurred and all the expectations that were broken
final class With1[+A](val parser: Parser0[A]) extends AnyVal
Enables syntax to access product01, product and flatMap01
This helps us build Parser instances when starting from
a Parser0
sealed class Soft0[+A](parser: Parser0[A])
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 Soft[+A](parser: Parser[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 either consume 1 or more, do not rewind
final class Soft01[+A](val parser: Parser0[A]) extends AnyVal
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 ParserMethods[A](self: Parser[A]) extends AnyVal
Methods with complex variance type signatures due to covariance.

Inherited types

type MirroredLabel <: String
The name of the type
Inhertied from
Mirror
type MirroredElemLabels <: Tuple
The names of the product elements
Inhertied from
Mirror

Value members

Methods

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 ignoreCase(str: String): Parser[Unit]
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 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 string(str: String): Parser[Unit]
Parse a given string or
fail. This backtracks on failure
this is an error if the string is empty
def string0(str: String): Parser0[Unit]
Parse a potentially empty string or
fail. This backtracks on failure
def ignoreCase0(str: String): Parser0[Unit]
Parse a potentially empty string, in a case-insensitive manner,
or fail. This backtracks on failure
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.
This is the same as parsers.foldLeft(fail)(.orElse())
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.
This is the same as parsers.foldLeft(fail)(.orElse())
def stringIn(strings: Iterable[String]): Parser[String]
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
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 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 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 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 length0(len: Int): Parser0[String]
if len < 1, the same as pure("")
else length(len)
def length(len: Int): Parser[String]
Parse the next len characters where len > 0
if (len < 1) throw IllegalArgumentException
def repAs0[A, B](p1: Parser[A])(acc: Accumulator0[A, B]): Parser0[B]
Repeat the parser 0 or more times
Note
this can wind up parsing nothing
def repAs0[A, B](p1: Parser[A], 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[A, B](p1: Parser[A], 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[A, B](p1: Parser[A], 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 succesfully
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repExactlyAs[A, B](p: Parser[A], times: Int)(acc: Accumulator[A, B]): Parser[B]
Repeat the parser exactly times times
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repSep[A](p1: Parser[A], sep: Parser0[Any]): Parser[NonEmptyList[A]]
Repeat 1 or more times with a separator
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.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
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.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def repSep0[A](p1: Parser[A], sep: Parser0[Any]): Parser0[List[A]]
Repeat 0 or more times with a separator
def repSep0[A](p1: Parser[A], 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[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.
Throws
java.lang.IllegalArgumentException
java.lang.IllegalArgumentException
def product0[A, B](first: Parser0[A], second: Parser0[B]): Parser0[(A, B)]
parse first then second
def product10[A, B](first: Parser[A], second: Parser0[B]): Parser[(A, B)]
product with the first argument being a Parser
def product01[A, B](first: Parser0[A], second: Parser[B]): Parser[(A, B)]
product with the second argument being a Parser
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. 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. 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. By contrast product will be a failure in
that case
see @Parser.soft
def map0[A, B](p: Parser0[A])(fn: A => B): Parser0[B]
transform a Parser0 result
def map[A, B](p: Parser[A])(fn: A => B): Parser[B]
transform a Parser result
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.
This should be more efficient than flatMap since
the fn Parser0 is evaluated once, not on every item
parsed
def select[A, B](p: Parser[Either[A, B]])(fn: Parser0[A => B]): Parser[B]
Parser version of select
def flatMap0[A, B](pa: Parser0[A])(fn: A => Parser0[B]): Parser0[B]
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 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. 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. 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. 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 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. 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 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 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.
e.g. parsing a number then validate that it is bounded.
def anyChar: Parser[Char]
Parse 1 character from the string
def charIn(cs: Iterable[Char]): Parser[Char]
An empty iterable is the same as fail
def ignoreCaseCharIn(cs: Iterable[Char]): Parser[Char]
Parse any single character in a set of characters as lower or upper case
def ignoreCaseCharIn(c0: Char, cs: Char*): Parser[Char]
Parse any single character in a set of characters as lower or upper case
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 charWhere(fn: Char => Boolean): Parser[Char]
parse one character that matches a given function
def charsWhile0(fn: Char => Boolean): Parser0[String]
Parse a string while the given function is true
def charsWhile(fn: Char => Boolean): Parser[String]
Parse a string while the given function is true
parses at least one character
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 until(p: Parser0[Any]): Parser[String]
parse one or more characters as long as they don't match p
def void0(pa: Parser0[Any]): Parser0[Unit]
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 void(pa: Parser[Any]): Parser[Unit]
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 string0(pa: Parser0[Any]): Parser0[String]
Discard the result A and instead capture the matching string
this is optimized to avoid internal allocations
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 not(pa: Parser0[Any]): Parser0[Unit]
returns a parser that succeeds if the
current parser fails.
Note, this parser backtracks (never returns an arresting failure)
def peek(pa: Parser0[Any]): Parser0[Unit]
a parser that consumes nothing when
it succeeds, basically rewind on success
def index: Parser0[Int]
return the current position in the string
we are parsing. This lets you record position information
in your ASTs you are parsing
def start: Parser0[Unit]
succeeds when we are at the start
def end: Parser0[Unit]
succeeds when we are at the end
def backtrack0[A](pa: Parser0[A]): Parser0[A]
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 backtrack[A](pa: Parser[A]): Parser[A]
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 as0[B](pa: Parser0[Any], b: B): Parser0[B]
Replaces parsed values with the given value.
def as[B](pa: Parser[Any], b: B): Parser[B]
Replaces parsed values with the given value.

Fields

val Fail: Parser[Nothing]
A parser that always fails with an epsilon failure
val unit: Parser0[Unit]
A parser that returns unit

Implicits

Implicits

implicit val catsInstancesParser: FlatMap[[A] =>> Parser[A]] & Defer[[A] =>> Parser[A]] & MonoidK[[A] =>> Parser[A]] & FunctorFilter[[A] =>> Parser[A]]