Value Members

1.  final def !=(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

2.  final def ##: Int

   Definition Classes

   AnyRef → Any

3.  final def ==(arg0: Any): Boolean

   Definition Classes

   AnyRef → Any

4.  final def asInstanceOf[T0]: T0

   Definition Classes

   Any

5.  def clone(): AnyRef

   Attributes

   protected[lang]

   Definition Classes

   AnyRef

   Annotations

   @throws(classOf[java.lang.CloneNotSupportedException]) @native()

6.  final def eq(arg0: AnyRef): Boolean

   Definition Classes

   AnyRef

7.  def equals(arg0: AnyRef): Boolean

   Definition Classes

   AnyRef → Any

8.  def finalize(): Unit

   Attributes

   protected[lang]

   Definition Classes

   AnyRef

   Annotations

   @throws(classOf[java.lang.Throwable])

9.  final def getClass(): Class[_ <: AnyRef]

   Definition Classes

   AnyRef → Any

   Annotations

   @native()

10.  def hashCode(): Int

    Definition Classes

    AnyRef → Any

    Annotations

    @native()

11.  final def isInstanceOf[T0]: Boolean

    Definition Classes

    Any

12.  def left[A, B, C >: B](p: Parsley[A], op: => Parsley[(C, A) => B], x: C)(implicit wrap: (A) => C): Parsley[C]

    This combinator handles left-associative parsing, and application of, zero or more binary operators between zero or more values.

    This combinator handles left-associative parsing, and application of, zero or more binary operators between zero or more values.

    First parse p, then parse op followed by a p repeatedly. The results of the ps, x1 through xn, are combined with the results of the ops, f1 through fn-1, with left-associative application: fn-1(fn-2(..f1(x1, x2).., xn-1), xn). This application is then returned as the result of the combinator. If p or op fails having consumed input at any point, the whole combinator fails. If no p could be parsed, this combinator will return a default result x.

    Compared with chain.left, this combinator allows the types of the operators to more accurately encode their associativity in their types. The recursive values of type C may only be applied on the left-hand side of the operators.

    A

    the type of the values.

    B

    the type returned by the operator, which must be a subtype of the result type C.

    C

    the result type of the chain, which also fits into the recursive application site of the operators.

    p

    the value to be parsed.

    op

    the operator between each value.

    x

    the default value to return if no ps can be parsed.

    wrap

    a function that can convert the value type into the result type, this is provided automatically when A <:< C.

    returns

    a parser that parses alternating p and op, ending in a p and applies their results left-associatively or returns x if no p was parsed.

    Example:

    1. scala> import parsley.expr.infix
       scala> import parsley.character.{digit, char}
       scala> sealed trait Expr
       scala> case class Add(x: Expr, y: Num) extends Expr
       scala> case class Num(x: Int) extends Expr
       scala> val expr = infix.left[Num, Add, Expr](digit.map(d => Num(d.asDigit)), char('+') #> Add, Num(0))
       scala> expr.parse("1+2+3+4")
       val res0 = Success(Add(Add(Add(Num(1), Num(2)), Num(3)), Num(4)))
       scala> expr.parse("")
       val res1 = Success(Num(0))

    Since

    4.0.0

    See also

    chain.left for a version where the types must match, allowing for flexibility to change the associativity.

13.  def left1[A, B, C >: B](p: Parsley[A], op: => Parsley[(C, A) => B])(implicit wrap: (A) => C): Parsley[C]

    This combinator handles left-associative parsing, and application of, zero or more binary operators between one or more values.

    This combinator handles left-associative parsing, and application of, zero or more binary operators between one or more values.

    First parse p, then parse op followed by a p repeatedly. The results of the ps, x1 through xn, are combined with the results of the ops, f1 through fn-1, with left-associative application: fn-1(fn-2(..f1(x1, x2).., xn-1), xn). This application is then returned as the result of the combinator. If p or op fails having consumed input at any point, the whole combinator fails.

    Compared with chain.left1, this combinator allows the types of the operators to more accurately encode their associativity in their types. The recursive values of type C may only be applied on the left-hand side of the operators.

    A

    the type of the values.

    B

    the type returned by the operator, which must be a subtype of the result type C.

    C

    the result type of the chain, which also fits into the recursive application site of the operators.

    p

    the value to be parsed.

    op

    the operator between each value.

    wrap

    a function that can convert the value type into the result type, this is provided automatically when A <:< C.

    returns

    a parser that parses alternating p and op, ending in a p and applies their results left-associatively.

    Example:

    1. scala> import parsley.expr.infix
       scala> import parsley.character.{digit, char}
       scala> sealed trait Expr
       scala> case class Add(x: Expr, y: Num) extends Expr
       scala> case class Num(x: Int) extends Expr
       scala> val expr = infix.left1[Num, Add, Expr](digit.map(d => Num(d.asDigit)), char('+') #> Add)
       scala> expr.parse("1+2+3+4")
       val res0 = Success(Add(Add(Add(Num(1), Num(2)), Num(3)), Num(4)))
       scala> expr.parse("")
       val res1 = Failure(..)

    Since

    4.0.0

    See also

    chain.left1 for a version where the types must match, allowing for flexibility to change the associativity.

14.  final def ne(arg0: AnyRef): Boolean

    Definition Classes

    AnyRef

15.  final def notify(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

16.  final def notifyAll(): Unit

    Definition Classes

    AnyRef

    Annotations

    @native()

17.  def right[A, B, C >: B](p: Parsley[A], op: => Parsley[(A, C) => B], x: C)(implicit wrap: (A) => C): Parsley[C]

    This combinator handles right-associative parsing, and application of, zero or more binary operators between zero or more values.

    This combinator handles right-associative parsing, and application of, zero or more binary operators between zero or more values.

    First parse p, then parse op followed by a p repeatedly. The results of the ps, x1 through xn, are combined with the results of the ops, f1 through fn-1, with right-associative application: f1(x1, f2(x2, ..fn-1(xn-1, xn)..)). This application is then returned as the result of the combinator. If p or op fails having consumed input at any point, the whole combinator fails. If no p could be parsed, this combinator will return a default result x.

    Compared with chain.right, this combinator allows the types of the operators to more accurately encode their associativity in their types. The recursive values of type C may only be applied on the right-hand side of the operators.

    A

    the type of the values.

    B

    the type returned by the operator, which must be a subtype of the result type C.

    C

    the result type of the chain, which also fits into the recursive application site of the operators.

    p

    the value to be parsed.

    op

    the operator between each value.

    x

    the default value to return if no ps can be parsed.

    wrap

    a function that can convert the value type into the result type, this is provided automatically when A <:< C.

    returns

    a parser that parses alternating p and op, ending in a p and applies their results right-associatively or returns x if no p was parsed.

    Example:

    1. scala> import parsley.expr.infix
       scala> import parsley.character.{digit, char}
       scala> sealed trait Expr
       scala> case class Add(x: Num, y: Expr) extends Expr
       scala> case class Num(x: Int) extends Expr
       scala> val expr = infix.right[Num, Add, Expr](digit.map(d => Num(d.asDigit)), char('+') #> Add, Num(0))
       scala> expr.parse("1+2+3+4")
       val res0 = Success(Add(Num(1), Add(Num(2), Add(Num(3), Num(4)))))
       scala> expr.parse("")
       val res1 = Success(Num(0))

    Since

    4.0.0

    See also

    chain.right for a version where the types must match, allowing for flexibility to change the associativity.

18.  def right1[A, B, C >: B](p: Parsley[A], op: => Parsley[(A, C) => B])(implicit wrap: (A) => C): Parsley[C]

    This combinator handles right-associative parsing, and application of, zero or more binary operators between one or more values.

    This combinator handles right-associative parsing, and application of, zero or more binary operators between one or more values.

    First parse p, then parse op followed by a p repeatedly. The results of the ps, x1 through xn, are combined with the results of the ops, f1 through fn-1, with right-associative application: f1(x1, f2(x2, ..fn-1(xn-1, xn)..)). This application is then returned as the result of the combinator. If p or op fails having consumed input at any point, the whole combinator fails.

    Compared with chain.right1, this combinator allows the types of the operators to more accurately encode their associativity in their types. The recursive values of type C may only be applied on the right-hand side of the operators.

    A

    the type of the values.

    B

    the type returned by the operator, which must be a subtype of the result type C.

    C

    the result type of the chain, which also fits into the recursive application site of the operators.

    p

    the value to be parsed.

    op

    the operator between each value.

    wrap

    a function that can convert the value type into the result type, this is provided automatically when A <:< C.

    returns

    a parser that parses alternating p and op, ending in a p and applies their results right-associatively.

    Example:

    1. scala> import parsley.expr.infix
       scala> import parsley.character.{digit, char}
       scala> sealed trait Expr
       scala> case class Add(x: Num, y: Expr) extends Expr
       scala> case class Num(x: Int) extends Expr
       scala> val expr = infix.right1[Num, Add, Expr](digit.map(d => Num(d.asDigit)), char('+') #> Add))
       scala> expr.parse("1+2+3+4")
       val res0 = Success(Add(Num(1), Add(Num(2), Add(Num(3), Num(4)))))
       scala> expr.parse("")
       val res1 = Failure(..)

    Since

    4.0.0

    See also

    chain.right1 for a version where the types must match, allowing for flexibility to change the associativity.

19.  final def synchronized[T0](arg0: => T0): T0

    Definition Classes

    AnyRef

20.  def toString(): String

    Definition Classes

    AnyRef → Any

21.  final def wait(): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

22.  final def wait(arg0: Long, arg1: Int): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException])

23.  final def wait(arg0: Long): Unit

    Definition Classes

    AnyRef

    Annotations

    @throws(classOf[java.lang.InterruptedException]) @native()