infix

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.

Attributes

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.

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.

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('+') #> 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

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.

Attributes

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.

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.

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('+') #> 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

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.

Attributes

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.

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.

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('+') #> 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

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.

Attributes

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.

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.

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('+') #> 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

infix

Attributes

Members list

Value members

Concrete methods

Attributes

Attributes

Attributes

Attributes