Value Members

1.  object character

   Provides implicit conversions for characters and strings into parsers.

   Provides implicit conversions for characters and strings into parsers.

   The use of char and string can be distracting to the overall structure of the parser with respect to the grammar. This module exposes combinators that can implicitly convert Scala's string and character literals so that they represent parsers. These will not be whitespace sensitive.

   Since

   3.0.0

2.  object combinator

   Provides implicit conversions for parsers into unit parsers, and other implicits involving combinators.

   Provides implicit conversions for parsers into unit parsers, and other implicits involving combinators.

   Since

   3.0.0

3.  object lift

   This module provides the "lift syntax", which enables a lift combinator on functions of arities up to 22, applying the function across the results of several parsers.

   This module provides the "lift syntax", which enables a lift combinator on functions of arities up to 22, applying the function across the results of several parsers.

   Example:

   1. scala> import parsley.character.char
      scala> import parsley.implicits.lift.{Lift2, Lift3}
      scala> case class Add(x: Int, y: Int)
      scala> val p = Add.lift(char('a') #> 4, char('b') #> 5)
      scala> p.parse("ab")
      val res0 = Success(Add(4, 5))
      scala> val f = (x: Int, y: Int, z: Int) => x * y + z
      scala> val q = f.lift(char('a') #> 3, char('b') #> 2, char('c') #> 5)
      scala> q.parse("abc")
      val res1 = Success(11)
      scala> q.parse("ab")
      val res2 = Failure(..)

   Since

   3.0.0

   Note

   a limitation of this syntax is that it requires the function's type to be fully known. For a version of this syntax that behaves better with type inference, see zipped.

4.  object zipped

   This module provides alternatives to the f.lift(x, y) syntax, (x, y).zipped(f), which works better with type inference.

   This module provides alternatives to the f.lift(x, y) syntax, (x, y).zipped(f), which works better with type inference.

   Also enables a parameterless zipped method, to pair an arbitrary number of parsers such that (p, q).zipped = p.zip(q).

   Thanks to Andrei Gramescu and George Stacey for ensuring that these combinators even exist in the first place.

   Example:

   1. scala> import parsley.character.char
      scala> import parsley.implicits.zipped.{Zipped2, Zipped3}
      scala> case class Add(x: Int, y: Int)
      scala> val p = (char('a') #> 4, char('b') #> 5).zipped(Add)
      scala> p.parse("ab")
      val res0 = Success(Add(4, 5))
      scala> val q = (char('a') #> 3, char('b') #> 2, char('c') #> 5).zipped((x, y, z) => x * y + z)
      scala> q.parse("abc")
      val res1 = Success(11)
      scala> q.parse("ab")
      val res2 = Failure(..)

   Since

   3.0.0

   Note

   these methods are not lazy like the lift syntax or liftN functions! Use the prefix ~ combinator to make arguments lazy where necessary.