object Parser
- Source
- Parser.scala
- Alphabetic
- By Inheritance
- Parser
- AnyRef
- Any
- Hide All
- Show All
- Public
- All
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[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
-
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[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native() @HotSpotIntrinsicCandidate()
-
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
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
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
def
hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
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
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
-
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 thanmax
Repeat the parser
min
or more times, but no more thanmax
The parser fails if it can't match at least
min
times After repeating the parsermax
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 timesRepeat the parser
min
or more timesThe 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
timesRepeat 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 tomax
times with a separator, at least once.Repeat
min
or more, up tomax
times with a separator, at least once.- Exceptions thrown
java.lang.IllegalArgumentException
ifmin <= 0
ormax < 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
ifmin <= 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 tomax
times with a separator.Repeat
min
or more, up tomax
times with a separator.- Exceptions thrown
java.lang.IllegalArgumentException
ifmin < 0
ormax < 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
ifmin < 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(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
-
final
def
wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws( ... ) @native()
-
final
def
wait(): 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
- object Expectation