parsley
4.4.0-M5
API
Generated with
parsley/parsley/parsley.expr/infix

infix

parsley.expr.infix$
object infix

This module contains the very useful chaining family of combinators, which are mostly used to parse operators and expressions of varying fixities. It is a more low-level API compared with precedence.

Compared with the combinators in chain, these allow for more freedom in the type of the values and the operators.

Attributes

Since

4.0.0

Source
infix.scala
Graph
Supertypes
class Object
trait Matchable
class Any
Self type
infix.type

Members list

Value members

Concrete methods

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.

Type parameters

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.

Value parameters

op

the operator between each value.

p

the value to be parsed.

wrap

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

x

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

Attributes

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.

See also

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

Since

4.0.0

Example 

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('+').as(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))
Source
infix.scala
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.

Type parameters

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.

Value parameters

op

the operator between each value.

p

the value to be parsed.

wrap

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

Attributes

Returns

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

See also

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

Since

4.0.0

Example 

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('+').as(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(..)
Source
infix.scala
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.

Type parameters

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.

Value parameters

op

the operator between each value.

p

the value to be parsed.

wrap

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

x

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

Attributes

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.

See also

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

Since

4.0.0

Example 

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('+').as(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))
Source
infix.scala
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.

Type parameters

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.

Value parameters

op

the operator between each value.

p

the value to be parsed.

wrap

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

Attributes

Returns

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

See also

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

Since

4.0.0

Example 

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('+').as(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(..)
Source
infix.scala
Generated with