combinator
This module contains a huge number of pre-made combinators that are very useful for a variety of purposes.
In particular, it contains combinators for: performing a parser iteratively, collecting all the results; querying whether or not any input is left; optionally performing parsers; parsing delimited constructions; handling multiple possible alternatives or parsers to sequence; handling more complex conditional execution; and more.
Attributes
- Since:
2.2.0
- Source:
- combinator.scala
- Graph
- Supertypes
- Self type
- combinator.type
Members list
Iterative Combinators
These combinators all execute a given parser an unbounded number of times, until either it fails, or another
parser succeeds, depending on the combinator. Depending on the combinator, all of the results produced by the
repeated execution of the parser may be returned in a List
. These are almost essential for any practical parsing
task.
This combinator repeatedly parses a given parser zero or more times, collecting the results into a list.
This combinator repeatedly parses a given parser zero or more times, collecting the results into a list.
Parses a given parser, p
, repeatedly until it fails. If p
failed having consumed input,
this combinator fails. Otherwise when p
fails without consuming input, this combinator
will return all of the results, x1
through xn
(with n >= 0
), in a list: List(x1, .., xn)
.
If p
was never successful, the empty list is returned.
Attributes
- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
until it fails, returning the list of all the successful results.- Since:
2.2.0
- Example:
scala> import parsley.character.string scala> import parsley.combinator.many scala> val p = many(string("ab")) scala> p.parse("") val res0 = Success(Nil) scala> p.parse("ab") val res1 = Success(List("ab")) scala> p.parse("abababab") val res2 = Success(List("ab", "ab", "ab", "ab")) scala> p.parse("aba") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser n
or more times, collecting the results into a list.
This combinator repeatedly parses a given parser n
or more times, collecting the results into a list.
Parses a given parser, p
, repeatedly until it fails. If p
failed having consumed input,
this combinator fails. Otherwise when p
fails without consuming input, this combinator
will return all of the results, x1
through xm
(with m >= n
), in a list: List(x1, .., xm)
.
If p
was not successful at least n
times, this combinator fails.
Attributes
- n
the minimum number of
p
s required.- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
until it fails, returning the list of all the successful results.- Note:
many(p) == many(0, p)
andsome(p) == many(1, p)
.- Example:
scala> import parsley.character.string scala> import parsley.combinator.manyN scala> val p = manyN(2, string("ab")) scala> p.parse("") val res0 = Failure(..) scala> p.parse("ab") val res1 = Failure(..) scala> p.parse("abababab") val res2 = Success(List("ab", "ab", "ab", "ab")) scala> p.parse("aba") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser zero or more times, until the end
parser succeeds, collecting the results into a list.
This combinator repeatedly parses a given parser zero or more times, until the end
parser succeeds, collecting the results into a list.
First tries to parse end
, if it fails without consuming input, then parses p
, which must succeed. This repeats until end
succeeds.
When end
does succeed, this combinator will return all of the results generated by p
, x1
through xn
(with n >= 0
), in a
list: List(x1, .., xn)
. If end
could be parsed immediately, the empty list is returned.
Attributes
- end
the parser that stops the parsing of
p
.- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
untilend
succeeds, returning the list of all the successful results.- Example:
This can be useful for scanning comments:
scala> import parsley.character.{string, item, endOfLine} scala> import parsley.combinator.many scala> val comment = string("//") *> manyUntil(item, endOfLine) scala> p.parse("//hello world") val res0 = Failure(..) scala> p.parse("//hello world\n") val res1 = Success(List('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')) scala> p.parse("//\n") val res2 = Success(Nil)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser zero or more times, ignoring the results.
This combinator repeatedly parses a given parser zero or more times, ignoring the results.
Parses a given parser, p
, repeatedly until it fails. If p
failed having consumed input,
this combinator fails. Otherwise when p
fails without consuming input, this combinator
will succeed.
Attributes
- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
until it fails, returning unit.- Since:
2.2.0
- Example:
scala> import parsley.character.string scala> import parsley.combinator.skipMany scala> val p = skipMany(string("ab")) scala> p.parse("") val res0 = Success(()) scala> p.parse("ab") val res1 = Success(()) scala> p.parse("abababab") val res2 = Success(()) scala> p.parse("aba") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser n
or more times, ignoring the results.
This combinator repeatedly parses a given parser n
or more times, ignoring the results.
Parses a given parser, p
, repeatedly until it fails. If p
failed having consumed input,
this combinator fails. Otherwise when p
fails without consuming input, this combinator
will succeed. The parser p
must succeed at least n
times.
Attributes
- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
until it fails, returning unit.- Example:
scala> import parsley.character.string scala> import parsley.combinator.skipManyN scala> val p = skipManyN(2, string("ab")) scala> p.parse("") val res0 = Failure(..) scala> p.parse("ab") val res1 = Failure(..) scala> p.parse("abababab") val res2 = Success(()) scala> p.parse("aba") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser one or more times, ignoring the results.
This combinator repeatedly parses a given parser one or more times, ignoring the results.
Parses a given parser, p
, repeatedly until it fails. If p
failed having consumed input,
this combinator fails. Otherwise when p
fails without consuming input, this combinator
will succeed. The parser p
must succeed at least once.
Attributes
- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
until it fails, returning unit.- Example:
scala> import parsley.character.string scala> import parsley.combinator.skipSome scala> val p = skipSome(string("ab")) scala> p.parse("") val res0 = Failure(..) scala> p.parse("ab") val res1 = Success(()) scala> p.parse("abababab") val res2 = Success(()) scala> p.parse("aba") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser one or more times, collecting the results into a list.
This combinator repeatedly parses a given parser one or more times, collecting the results into a list.
Parses a given parser, p
, repeatedly until it fails. If p
failed having consumed input,
this combinator fails. Otherwise when p
fails without consuming input, this combinator
will return all of the results, x1
through xn
(with n >= 1
), in a list: List(x1, .., xn)
.
If p
was not successful at least one time, this combinator fails.
Attributes
- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
until it fails, returning the list of all the successful results.- Example:
scala> import parsley.character.string scala> import parsley.combinator.some scala> val p = some(string("ab")) scala> p.parse("") val res0 = Failure(..) scala> p.parse("ab") val res1 = Success(List("ab")) scala> p.parse("abababab") val res2 = Success(List("ab", "ab", "ab", "ab")) scala> p.parse("aba") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator repeatedly parses a given parser one or more times, until the end
parser succeeds, collecting the results into a list.
This combinator repeatedly parses a given parser one or more times, until the end
parser succeeds, collecting the results into a list.
First ensures that trying to parse end
fails, then tries to parse p
. If it succeed then it will repeatedly: try to parse end
, if it fails
without consuming input, then parses p
, which must succeed. When end
does succeed, this combinator will return all of the results
generated by p
, x1
through xn
(with n >= 1
), in a list: List(x1, .., xn)
. The parser p
must succeed at least once
before end
succeeds.
Attributes
- end
the parser that stops the parsing of
p
.- p
the parser to execute multiple times.
- Returns:
a parser that parses
p
untilend
succeeds, returning the list of all the successful results.- Example:
This can be useful for scanning comments:
scala> import parsley.character.{string, item, endOfLine} scala> import parsley.combinator.many scala> val comment = string("//") *> someUntil(item, endOfLine) scala> p.parse("//hello world") val res0 = Failure(..) scala> p.parse("//hello world\n") val res1 = Success(List('h', 'e', 'l', 'l', 'o', ' ', 'w', 'o', 'r', 'l', 'd')) scala> p.parse("//\n") val res2 = Failure(..) scala> p.parse("//a\n") val res3 = Success(List('a'))
- Source:
- combinator.scala
Input Query Combinators
These combinators do not consume input, but they allow for querying of the input stream - specifically checking
whether or not there is more input that can be consumed or not. In particular, most parsers should be making
use of eof
to ensure that the parser consumes all the input available at the end of the parse.
This parser only succeeds at the end of the input.
This parser only succeeds at the end of the input.
Equivalent to notFollowedBy(item)
.
Attributes
- Example:
scala> import parsley.combinator.eof scala> eof.parse("a") val res0 = Failure(..) scala> eof.parse("") val res1 = Success(())
- Source:
- combinator.scala
This parser only succeeds if there is still more input.
This parser only succeeds if there is still more input.
Equivalent to lookAhead(item).void
.
Attributes
- Example:
scala> import parsley.combinator.more scala> more.parse("") val res0 = Failure(..) scala> more.parse("a") val res1 = Success(())
- Source:
- combinator.scala
Optional Parsing Combinators
These combinators allow for the possible parsing of some parser. If the parser succeeds, that is ok
so long as it did not consume input. Be aware that the result of the success may be replaced with
these combinators, with the exception of option
, which still preserves the result.
This combinator tries to parse p
, wrapping its result in a Some
if it succeeds, or returns None
if it fails.
This combinator tries to parse p
, wrapping its result in a Some
if it succeeds, or returns None
if it fails.
Tries to parse p
. If p
succeeded, producing x
, then Some(x)
is returned. Otherwise, if p
failed
without consuming input, then None
is returned instead.
Attributes
- p
the parser to try to parse.
- Returns:
a parser that tries to parse
p
, but can still succeed withNone
if that was not possible.- Example:
scala> import parsley.combinator.option scala> import parsley.character.string scala> val p = option(string("abc")) scala> p.parse("") val res0 = Success(None) scala> p.parse("abc") val res1 = Success(Some("abc")) scala> p.parse("ab") val res2 = Failure(..)
- Source:
- combinator.scala
This combinator will parse p
if possible, otherwise will do nothing.
This combinator will parse p
if possible, otherwise will do nothing.
Tries to parse p
. If p
succeeds, or fails without consuming input then this combinator is successful. Otherwise, if p
failed
having consumed input, this combinator fails.
Attributes
- p
the parser to try to parse.
- Returns:
a parser that tries to parse
p
.- Note:
equivalent to
optionalAs(p, ())
.- Example:
scala> import parsley.combinator.optional scala> import parsley.character.string scala> val p = optional(string("abc")) scala> p.parse("") val res0 = Success(()) scala> p.parse("abc") val res1 = Success(()) scala> p.parse("ab") val res2 = Failure(..)
- Source:
- combinator.scala
This combinator will parse p
if possible, otherwise will do nothing.
This combinator will parse p
if possible, otherwise will do nothing.
Tries to parse p
. If p
succeeds, or fails without consuming input then this combinator is successful and returns x
. Otherwise,
if p
failed having consumed input, this combinator fails.
Attributes
- p
the parser to try to parse.
- x
the value to return regardless of how
p
performs.- Returns:
a parser that tries to parse
p
, returningx
regardless of success or failure.- Example:
scala> import parsley.combinator.optionalAs scala> import parsley.character.string scala> val p = optionalAs(string("abc"), 7) scala> p.parse("") val res0 = Success(7) scala> p.parse("abc") val res1 = Success(7) scala> p.parse("ab") val res2 = Failure(..)
- Source:
- combinator.scala
Separated Values Combinators
These combinators are concerned with delimited parsing, where one parser is repeated but delimited by another one.
In each of these cases p
is the parser of interest and sep
is the delimeter. These combinators mainly differ
in either the number of p
s they require, or exactly where the delimeters are allowed (only between, always
trailing, or either). In all cases, they return the list of results generated by the repeated parses of p
.
This combinator parses zero or more occurrences of p
, separated and ended by sep
.
This combinator parses zero or more occurrences of p
, separated and ended by sep
.
Behaves just like endBy1
, except does not require an initial p
and sep
, returning the empty list instead.
Attributes
- p
the parser whose results are collected into a list.
- sep
the delimiter that must be parsed between every
p
.- Returns:
a parser that parses
p
delimited bysep
, returning the list ofp
's results.- Example:
scala> ... scala> val args = endBy(int, string(";\n")) scala> args.parse("7;\n3;\n2") val res0 = Failure(..) scala> args.parse("") val res1 = Success(Nil) scala> args.parse("1;\n") val res2 = Success(List(1)) scala> args.parse("1;\n2;\n") val res3 = Success(List(1, 2))
- Source:
- combinator.scala
This combinator parses one or more occurrences of p
, separated and ended by sep
.
This combinator parses one or more occurrences of p
, separated and ended by sep
.
Parses p
followed by sep
one or more times.
The results of the p
's, x1
through xn
, are returned as List(x1, .., xn)
.
If p
or sep
fails having consumed input, the whole parser fails.
Attributes
- p
the parser whose results are collected into a list.
- sep
the delimiter that must be parsed between every
p
.- Returns:
a parser that parses
p
delimited bysep
, returning the list ofp
's results.- Example:
scala> ... scala> val args = endBy1(int, string(";\n")) scala> args.parse("7;\n3;\n2") val res0 = Failure(..) scala> args.parse("") val res1 = Failure(..) scala> args.parse("1;\n") val res2 = Success(List(1)) scala> args.parse("1;\n2;\n") val res3 = Success(List(1, 2))
- Source:
- combinator.scala
This combinator parses zero or more occurrences of p
, separated by sep
.
This combinator parses zero or more occurrences of p
, separated by sep
.
Behaves just like sepBy1
, except does not require an initial p
, returning the empty list instead.
Attributes
- p
the parser whose results are collected into a list.
- sep
the delimiter that must be parsed between every
p
.- Returns:
a parser that parses
p
delimited bysep
, returning the list ofp
's results.- Example:
scala> ... scala> val args = sepBy(int, string(", ")) scala> args.parse("7, 3, 2") val res0 = Success(List(7, 3, 2)) scala> args.parse("") val res1 = Success(Nil) scala> args.parse("1") val res2 = Success(List(1)) scala> args.parse("1, 2, ") val res3 = Failure(..) // no trailing comma allowed
- Source:
- combinator.scala
This combinator parses one or more occurrences of p
, separated by sep
.
This combinator parses one or more occurrences of p
, separated by sep
.
First parses a p
. Then parses sep
followed by p
until there are no more sep
s.
The results of the p
's, x1
through xn
, are returned as List(x1, .., xn)
.
If p
or sep
fails having consumed input, the whole parser fails. Requires at least
one p
to have been parsed.
Attributes
- p
the parser whose results are collected into a list.
- sep
the delimiter that must be parsed between every
p
.- Returns:
a parser that parses
p
delimited bysep
, returning the list ofp
's results.- Example:
scala> ... scala> val args = sepBy1(int, string(", ")) scala> args.parse("7, 3, 2") val res0 = Success(List(7, 3, 2)) scala> args.parse("") val res1 = Failure(..) scala> args.parse("1") val res2 = Success(List(1)) scala> args.parse("1, 2, ") val res3 = Failure(..) // no trailing comma allowed
- Source:
- combinator.scala
This combinator parses zero or more occurrences of p
, separated and optionally ended by sep
.
This combinator parses zero or more occurrences of p
, separated and optionally ended by sep
.
Behaves just like sepEndBy1
, except does not require an initial p
, returning the empty list instead.
Attributes
- p
the parser whose results are collected into a list.
- sep
the delimiter that must be parsed between every
p
.- Returns:
a parser that parses
p
delimited bysep
, returning the list ofp
's results.- Example:
scala> ... scala> val args = sepEndBy(int, string(";\n")) scala> args.parse("7;\n3;\n2") val res0 = Success(List(7, 3, 2)) scala> args.parse("") val res1 = Success(Nil) scala> args.parse("1") val res2 = Success(List(1)) scala> args.parse("1;\n2;\n") val res3 = Success(List(1, 2))
- Source:
- combinator.scala
This combinator parses one or more occurrences of p
, separated and optionally ended by sep
.
This combinator parses one or more occurrences of p
, separated and optionally ended by sep
.
First parses a p
. Then parses sep
followed by p
until there are no more: if a final sep
exists, this is parsed.
The results of the p
's, x1
through xn
, are returned as List(x1, .., xn)
.
If p
or sep
fails having consumed input, the whole parser fails. Requires at least
one p
to have been parsed.
Attributes
- p
the parser whose results are collected into a list.
- sep
the delimiter that must be parsed between every
p
.- Returns:
a parser that parses
p
delimited bysep
, returning the list ofp
's results.- Example:
scala> ... scala> val args = sepEndBy1(int, string(";\n")) scala> args.parse("7;\n3;\n2") val res0 = Success(List(7, 3, 2)) scala> args.parse("") val res1 = Failure(..) scala> args.parse("1") val res2 = Success(List(1)) scala> args.parse("1;\n2;\n") val res3 = Success(List(1, 2))
- Source:
- combinator.scala
Multiple Branching/Sequencing Combinators
These combinators allow for testing or sequencing a large number of parsers in one go. Be careful, however, these are
variadic combinators and are necessarily (for compatibility with Scala 2) not lazy.
In such a case where laziness is desired without resorting to the other lazier combinators, there
is a neat trick: unroll the first iteration of the combinator, and use the corresponding regular combinator
to do that (i.e. <::>
or *>
): since these will have a lazy
right-hand side, the remaining variadic arguments will be kept lazily suspended until later. Alternatively,
it is possible to use the prefix ~
combinator to make any individual
arguments lazy as required, for example skip(p, ~q, r)
.
This combinator tries to parse each of the parsers ps
in order, until one of them succeeds.
This combinator tries to parse each of the parsers ps
in order, until one of them succeeds.
Finds the first parser in ps
which succeeds, returning its result. If none of the parsers
succeed, then this combinator fails. This combinator will always try and parse each of the
combinators until one succeeds, regardless of how they fail. The last argument will not
be wrapped in attempt
, as this is not necessary.
Attributes
- ps
the parsers to try, in order.
- Returns:
a parser that tries to parse one of
ps
.- See also:
- Note:
this combinator is not particularly efficient, because it may unnecessarily backtrack for each alternative.
- Example:
scala> import parsley.combinator.attemptChoice scala> import parsley.character.string scala> val p = attemptChoice(string("abc"), string("ab"), string("bc"), string("d")) scala> p.parse("abc") val res0 = Success("abc") scala> p.parse("ab") val res1 = Success("ab") scala> p.parse("bc") val res2 = Success("bc") scala> p.parse("x") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator tries to parse each of the parsers ps
in order, until one of them succeeds.
This combinator tries to parse each of the parsers ps
in order, until one of them succeeds.
Finds the first parser in ps
which succeeds, returning its result. If none of the parsers
succeed, then this combinator fails. If a parser fails having consumed input, this combinator
fails immediately.
Attributes
- ps
the parsers to try, in order.
- Returns:
a parser that tries to parse one of
ps
.- See also:
- Example:
scala> import parsley.combinator.choice scala> import parsley.character.string scala> val p = choice(string("abc"), string("ab"), string("bc"), string("d")) scala> p.parse("abc") val res0 = Success("abc") scala> p.parse("ab") val res1 = Failure(..) scala> p.parse("bc") val res2 = Success("bc") scala> p.parse("x") val res3 = Failure(..)
- Source:
- combinator.scala
This combinator will parse each of ps
in order, collecting the results.
This combinator will parse each of ps
in order, collecting the results.
Given the parsers ps
, consisting of p1
through pn
, parses
each in order. If they all succeed, producing the results x1
through xn
,
then List(x1, .., xn)
is returned. If any of the parsers fail, then
the whole combinator fails.
Attributes
- ps
parsers to be sequenced.
- Returns:
a parser that parses each of
ps
, returning the results in a list- See also:
- Since:
4.0.0
- Note:
be aware that all of the arguments to this combinator are in strict positions.
- Example:
scala> import parsley.combinator.sequence scala> import parsley.character.{char, item} scala> val p = sequence(char('a'), item, char('c')) scala> p.parse("abc") val res0 = Success(List('a', 'b', 'c')) scala> p.parse("ab") val res1 = Failure(..)
- Source:
- combinator.scala
This combinator will parse each of ps
in order, discarding the results.
This combinator will parse each of ps
in order, discarding the results.
Given the parsers ps
, consisting of p1
through pn
, parses
each in order. If they all succeed, this combinator succeeds. If any of
the parsers fail, then the whole combinator fails.
Attributes
- p
first parser to be sequenced
- ps
parsers to be sequenced.
- Returns:
a parser that parses each of
ps
, returning()
.- See also:
- Note:
be aware that all of the arguments to this combinator are in strict positions.
- Example:
scala> import parsley.combinator.skip scala> import parsley.character.{char, item} scala> val p = skip(char('a'), item, char('c')) scala> p.parse("abc") val res0 = Success(()) scala> p.parse("ab") val res1 = Failure(..)
- Source:
- combinator.scala
This combinator will parse each of the parsers generated by applying f
to xs
, in order, collecting the results.
This combinator will parse each of the parsers generated by applying f
to xs
, in order, collecting the results.
Given the values xs
, consisting of x1
through xn
, first creates
the parses f(x1)
through f(xn)
and then called sequence
on them.
Attributes
- f
the function used to generate parsers for each values
- xs
the values to turn into parsers and sequence.
- Returns:
a parser that sequences the parsers generated from applying
f
to each ofxs
.- See also:
- Since:
4.0.0
- Note:
be aware that all of the arguments to this combinator are in strict positions.
- Example:
// this is an OK implementation for `string`, which is common in Haskell. def string(str: String) = { traverse(char, str: _*).map(_.mkString) }
- Source:
- combinator.scala
Conditional Combinators
These combinators allow for the conditional extraction of a result, or the execution of a parser
based on another. They are morally related to branch
and select
but are
less fundamental.
This combinator can eliminate an Option
from the result of the parser p
.
This combinator can eliminate an Option
from the result of the parser p
.
First parse p
, if it succeeds returning Some(x)
, then return x
. However,
if p
fails, or returned None
, then this combinator fails.
Attributes
- p
the parser to parse and extract the result from.
- Returns:
a parser that tries to extract the result from
p
.- Example:
decide(option(p)) = p
- Source:
- combinator.scala
This combinator parses q
depending only if p
returns a None
.
This combinator parses q
depending only if p
returns a None
.
First parses p
. If p
returned Some(x)
, then x
is returned.
Otherwise, if p
returned None
then q
is parsed, producing y
,
and y
is returned. If p
or q
fails, the combinator fails.
Attributes
- p
the first parser, which returns an
Option
to eliminate.- q
a parser to execute when
p
returnsNone
, to provide a value of typeA
.- Returns:
a parser that either just parses
p
or bothp
andq
in order to return anA
.- Example:
decide(option(p), q) = p <|> q
- Source:
- combinator.scala
This combinator parses one of thenP
or elseP
depending on the result of parsing condP
.
This combinator parses one of thenP
or elseP
depending on the result of parsing condP
.
This is a lifted if
-statement. First, parse condP
: if it is successful and returns
true
, then parse thenP
; else, if it returned false
, parse elseP
; or, if condP
failed
then fail. If either of thenP
or elseP
fail, then this combinator also fails.
Most useful in conjunction with Registers, as this allows for decisions to be made based on state.
Attributes
- condP
the parser that yields the condition value.
- elseP
the parser to execute if the condition is
false.
- thenP
the parser to execute if the condition is
true
.- Returns:
a parser that conditionally parses
thenP
orelseP
aftercondP
.- Since:
4.0.0
- Example:
ifP(pure(true), p, _) == p ifP(pure(false), _, p) == p
- Source:
- combinator.scala
This combinator conditionally parses thenP
depending on the result of parsing condP
.
This combinator conditionally parses thenP
depending on the result of parsing condP
.
This is a lifted if
-statement. First, parse condP
: if it is successful and returns
true
, then parse thenP
; else, if it returned false
do nothing; or, if condP
failed
then fail. If thenP
fails, then this combinator also fails.
Most useful in conjunction with Registers, as this allows for decisions to be made based on state.
Attributes
- condP
the parser that yields the condition value.
- thenP
the parser to execute if the condition is
true
.- Returns:
a parser that conditionally parses
thenP
orelseP
aftercondP
.- Example:
when(pure(true), p) == p when(pure(false), _) == unit
- Source:
- combinator.scala
This combinator repeatedly parses p
so long as it returns true
.
This combinator repeatedly parses p
so long as it returns true
.
This is a lifted while
-loop. First, parse p
: if it is successful and
returns true
, then repeat; else if it returned false
stop; or, if it
failed then this combinator fails.
Most useful in conjunction with Registers, as this allows for decisions to be made
based on state. In particular, this can be used to define the forP
combinator.
Attributes
- p
the parser to repeatedly parse.
- Returns:
a parser that continues to parse
p
until it returnsfalse
.- Example:
def forP[A](init: Parsley[A], cond: =>Parsley[A => Boolean], step: =>Parsley[A => A])(body: =>Parsley[_]): Parsley[Unit] = { val reg = Reg.make[A] lazy val _cond = reg.gets(cond) lazy val _step = reg.modify(step) reg.put(init) *> when(_cond, whileP(body *> _step *> _cond)) }
- Source:
- combinator.scala
Miscellaneous
This combinator parses open
, followed by p
, and then close
.
This combinator parses open
, followed by p
, and then close
.
First parse open
, ignore its result, then parse, p
, producing x
. Finally, parse close
, ignoring its result.
If open
, p
, and close
all succeeded, then return x
. If any of them failed, this combinator fails.
Attributes
- close
the last parser to parse.
- open
the first parser to parse.
- p
the parser to parse between the other two.
- Returns:
a parser that reads
open
, thenp
, thenclose
and returns the result ofp
.- Example:
def braces[A](p: Parsley[A]) = between(char('{'), char('}'), p)
- Source:
- combinator.scala
This combinator parses exactly n
occurrences of p
, returning these n
results in a list.
This combinator parses exactly n
occurrences of p
, returning these n
results in a list.
Parses p
repeatedly up to n
times. If p
fails before n
is reached, then this combinator
fails. It is not required for p
to fail after the n
th parse. The results produced by
p
, x1
through xn
, are returned as List(x1, .., xn)
.
Attributes
- n
the number of times to repeat
p
.- p
the parser to repeat.
- Returns:
a parser that parses
p
exactlyn
times, returning a list of the results.- Since:
4.0.0
- Example:
scala> import parsley.character.item scala> import parsley.combinator.exactly scala> val p = exactly(3, item) scala> p.parse("ab") val res0 = Failure(..) scala> p.parse("abc") val res1 = Success(List('a', 'b', 'c')) scala> p.parse("abcd") val res2 = Success(List('a', 'b', 'c'))
- Source:
- combinator.scala