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
- Self type
- infix.type
Members list
Value members
Concrete methods
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 p
s, x1
through xn
, are combined with the results
of the op
s, 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
p
s can be parsed.- Returns:
a parser that parses alternating
p
andop
, ending in ap
and applies their results left-associatively or returnsx
if nop
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.
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 p
s, x1
through xn
, are combined with the results
of the op
s, 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
andop
, ending in ap
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.
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 p
s, x1
through xn
, are combined with the results
of the op
s, 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
p
s can be parsed.- Returns:
a parser that parses alternating
p
andop
, ending in ap
and applies their results right-associatively or returnsx
if nop
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.
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 p
s, x1
through xn
, are combined with the results
of the op
s, 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
andop
, ending in ap
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