combinator

parsley.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: class Object

trait Matchable

class Any
Self type: combinator.type

Members list

Grouped members

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, returning how many times it succeeded.

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 number of times p succeeded is returned as the result.

Value parameters

p: the parser to execute multiple times.

Attributes

Returns

the number of times p successfully parses

Since

4.4.0

Example

scala> import parsley.character.string
scala> import parsley.combinator.count
scala> val p = count(string("ab"))
scala> p.parse("")
val res0 = Success(0)
scala> p.parse("ab")
val res1 = Success(1)
scala> p.parse("abababab")
val res2 = Success(4)
scala> p.parse("aba")
val res3 = Failure(..)

Source

combinator.scala

This combinator repeatedly parses a given parser one or more times, returning how many times it succeeded.

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. The number of times p succeeded is returned as the result.

Value parameters

p: the parser to execute multiple times.

Attributes

Returns

the number of times p successfully parses

Since

4.4.0

Example

scala> import parsley.character.string
scala> import parsley.combinator.count1
scala> val p = count1(string("ab"))
scala> p.parse("")
val res0 = Failure(..)
scala> p.parse("ab")
val res1 = Success(1)
scala> p.parse("abababab")
val res2 = Success(4)
scala> p.parse("aba")
val res3 = Failure(..)

Source

combinator.scala

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.

Value parameters

p: the parser to execute multiple times.

Attributes

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.

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.

Value parameters

n: the minimum number of ps required.
p: the parser to execute multiple times.

Attributes

Returns

a parser that parses p until it fails, returning the list of all the successful results.

Note

many(p) == many(0, p) and some(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.

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.

Value parameters

end: the parser that stops the parsing of p.
p: the parser to execute multiple times.

Attributes

Returns

a parser that parses p until end 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.

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.

Value parameters

p: the parser to execute multiple times.

Attributes

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.

Value parameters

p: the parser to execute multiple times.

Attributes

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.

Value parameters

p: the parser to execute multiple times.

Attributes

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.

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.

Value parameters

p: the parser to execute multiple times.

Attributes

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.

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.

Value parameters

end: the parser that stops the parsing of p.
p: the parser to execute multiple times.

Attributes

Returns

a parser that parses p until end 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.someUntil
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.

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.

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.

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.

Value parameters

p: the parser to try to parse.

Attributes

Returns

a parser that tries to parse p, but can still succeed with None 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.

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.

Value parameters

p: the parser to try to parse.

Attributes

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.

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.

Value parameters

p: the parser to try to parse.
x: the value to return regardless of how p performs.

Attributes

Returns

a parser that tries to parse p, returning x 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 ps 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.

Behaves just like endBy1, except does not require an initial p and sep, returning the empty list instead.

Value parameters

p: the parser whose results are collected into a list.
sep: the delimiter that must be parsed between every p.

Attributes

Returns

a parser that parses p delimited by sep, returning the list of p'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.

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.

Value parameters

p: the parser whose results are collected into a list.
sep: the delimiter that must be parsed between every p.

Attributes

Returns

a parser that parses p delimited by sep, returning the list of p'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.

Behaves just like sepBy1, except does not require an initial p, returning the empty list instead.

Value parameters

p: the parser whose results are collected into a list.
sep: the delimiter that must be parsed between every p.

Attributes

Returns

a parser that parses p delimited by sep, returning the list of p'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.

First parses a p. Then parses sep followed by p until there are no more seps. 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.

Value parameters

p: the parser whose results are collected into a list.
sep: the delimiter that must be parsed between every p.

Attributes

Returns

a parser that parses p delimited by sep, returning the list of p'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.

Behaves just like sepEndBy1, except does not require an initial p, returning the empty list instead.

Value parameters

p: the parser whose results are collected into a list.
sep: the delimiter that must be parsed between every p.

Attributes

Returns

a parser that parses p delimited by sep, returning the list of p'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.

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.

Value parameters

p: the parser whose results are collected into a list.
sep: the delimiter that must be parsed between every p.

Attributes

Returns

a parser that parses p delimited by sep, returning the list of p'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.

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 atomic, as this is not necessary.

Value parameters

ps: the parsers to try, in order.

Attributes

Returns

a parser that tries to parse one of ps.

See also

<|>

atomic

Since

4.4.0

Note

this combinator is not particularly efficient, because it may unnecessarily backtrack for each alternative: a more efficient alternative for String is strings.

Example

scala> import parsley.combinator.atomicChoice
scala> import parsley.character.string
scala> val p = atomicChoice(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.

Value parameters

ps: the parsers to try, in order.

Attributes

Returns

a parser that tries to parse one of ps.

See also

<|>

attempt

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.

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.

Value parameters

ps: the parsers to try, in order.

Attributes

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.

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.

Value parameters

ps: parsers to be sequenced.

Attributes

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.

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.

Value parameters

p: first parser to be sequenced
ps: parsers to be sequenced.

Attributes

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.

Given the values xs, consisting of x1 through xn, first creates the parses f(x1) through f(xn) and then called sequence on them.

Value parameters

f: the function used to generate parsers for each values
xs: the values to turn into parsers and sequence.

Attributes

Returns

a parser that sequences the parsers generated from applying f to each of xs.

See also

sequence

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

Range Combinators

These combinators allow for the parsing of a specific parser either a specific number of times, or between a certain amount of times.

This combinator parses between min and max occurrences of p, returning the number of successes.

Parses p repeatedly a minimum of min times and up to max times both inclusive. If p fails before min is reached, then this combinator fails. It is not required for p to fail after the maxth parse. The results are discarded and the number of successful parses of p, n, is returned instead, such that min <= n <= max.

Value parameters

max: the maximum number of times to repeat p, inclusive.
min: the minimum number of times to repeat p, inclusive.
p: the parser to repeat.

Attributes

Returns

the number of times p parsed successfully.

Since

4.4.0

Example

scala> import parsley.character.item
scala> import parsley.combinator.count
scala> val p = count(min=3, max=5)(item)
scala> p.parse("ab")
val res0 = Failure(..)
scala> p.parse("abc")
val res1 = Success(3)
scala> p.parse("abcd")
val res2 = Success(4)
scala> p.parse("abcde")
val res2 = Success(5)
scala> p.parse("abcdef")
val res2 = Success(5)

Source

combinator.scala

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 nth parse. The results produced by p, x1 through xn, are returned as List(x1, .., xn).

Value parameters

n: the number of times to repeat p.
p: the parser to repeat.

Attributes

Returns

a parser that parses p exactly n 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

This combinator parses between min and max occurrences of p, returning these n results in a list.

Parses p repeatedly a minimum of min times and up to max times both inclusive. If p fails before min is reached, then this combinator fails. It is not required for p to fail after the maxth parse. The results produced by p, xmin through xmax, are returned as List(xmin, .., xmax).

Value parameters

max: the maximum number of times to repeat p, inclusive.
min: the minimum number of times to repeat p, inclusive.
p: the parser to repeat.

Attributes

Returns

the results of the successful parses of p.

Since

4.4.0

Example

scala> import parsley.character.item
scala> import parsley.combinator.range
scala> val p = range(min=3, max=5)(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', 'd'))
scala> p.parse("abcde")
val res2 = Success(List('a', 'b', 'c', 'd', 'e'))
scala> p.parse("abcdef")
val res2 = Success(List('a', 'b', 'c', 'd', 'e'))

Source

combinator.scala

This combinator parses between min and max occurrences of p but ignoring the results.

Value parameters

max: the maximum number of times to repeat p, inclusive.
min: the minimum number of times to repeat p, inclusive.
p: the parser to repeat.

Attributes

Since

4.4.0

Example

scala> import parsley.character.item
scala> import parsley.combinator.range_
scala> val p = range_(min=3, max=5)(item)
scala> p.parse("ab")
val res0 = Failure(..)
scala> p.parse("abc")
val res1 = Success(())
scala> p.parse("abcd")
val res2 = Success(())
scala> p.parse("abcde")
val res2 = Success(())
scala> p.parse("abcdef")
val res2 = Success(())

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.

First parse p, if it succeeds returning Some(x), then return x. However, if p fails, or returned None, then this combinator fails.

Value parameters

p: the parser to parse and extract the result from.

Attributes

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.

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.

Value parameters

p: the first parser, which returns an Option to eliminate.
q: a parser to execute when p returns None, to provide a value of type A.

Attributes

Returns

a parser that either just parses p or both p and q in order to return an A.

Example

decide(option(p), q) = p <|> q

Source

combinator.scala

This combinator verfies that the given parser returns true, or else fails.

First, parse p; if it succeeds then, so long at returns true, this guard(p) succeeds. Otherwise, if p either fails, or returns false, guard(p) will fail.

Value parameters

p: the parser that yields the condition value.

Attributes

Example

guard(pure(true)) == unit
guard(pure(false)) == empty
when(p.map(!_), empty) == guard(p)

Source

combinator.scala

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.

Value parameters

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.

Attributes

Returns

a parser that conditionally parses thenP or elseP after condP.

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 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.

Value parameters

condP: the parser that yields the condition value.
thenP: the parser to execute if the condition is true.

Attributes

Returns

a parser that conditionally parses thenP after condP.

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 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.

Value parameters

p: the parser to repeatedly parse.

Attributes

Returns

a parser that continues to parse p until it returns false.

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.

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.

Value parameters

close: the last parser to parse.
open: the first parser to parse.
p: the parser to parse between the other two.

Attributes

Returns

a parser that reads open, then p, then close and returns the result of p.

Example

def braces[A](p: Parsley[A]) = between(char('{'), char('}'), p)

Source

combinator.scala

In this article

Generated with