License	BSD-3-Clause
Maintainer	Jamie Willis, Gigaparsec Maintainers
Stability	experimental
Safe Haskell	Safe
Language	Haskell2010

Text.Gigaparsec.Expr.Infix

Contents

Binary Operator Chains
Unary Operator Chains
Module Re-export

Description

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 lower-level API than precedence.

Compared with the combinators in Text.Gigaparsec.Expr.Chain, these allow for more freedom in the type of the values and the operators.

Synopsis

infixl1 :: (a -> b) -> Parsec a -> Parsec (b -> a -> b) -> Parsec b
infixr1 :: (a -> b) -> Parsec a -> Parsec (a -> b -> b) -> Parsec b
infixn1 :: (a -> b) -> Parsec a -> Parsec (a -> a -> b) -> Parsec b
prefix :: (a -> b) -> Parsec (b -> b) -> Parsec a -> Parsec b
postfix :: (a -> b) -> Parsec a -> Parsec (b -> b) -> Parsec b
infixl1 :: (a -> b) -> Parsec a -> Parsec (b -> a -> b) -> Parsec b
infixr1 :: (a -> b) -> Parsec a -> Parsec (a -> b -> b) -> Parsec b
infixn1 :: (a -> b) -> Parsec a -> Parsec (a -> a -> b) -> Parsec b
prefix :: (a -> b) -> Parsec (b -> b) -> Parsec a -> Parsec b
postfix :: (a -> b) -> Parsec a -> Parsec (b -> b) -> Parsec b

Binary Operator Chains

These combinators allow for the chaining together of values and binary operators in either left-, right- or non-associative application.

infixl1 Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`.
-> Parsec a	`p`, the value to be parsed
-> Parsec (b -> a -> b)	`op`, the operator between each value.
-> Parsec b	a parser that parses alternating `p` and `op`, ending in a `p`, and applies their results left-associatively.

This combinator handles left-associative parsing, and the 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, x₁ through xₙ, are combined with the results of the ops, f₁ through fₙ₋₁, with left-associative application: fₙ₋₁ (fₙ₋₂ (..(f₁ x₁ x₂)..) xₙ₋₁) xₙ. 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 chainl1, this combinator allows the types of the operators to more accurately encode their associativity in their types. However, chainl1, in which a and b must match, allows for more flexibility to change the associativity.

infixr1 Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`.
-> Parsec a	`p`, the value to be parsed
-> Parsec (a -> b -> b)	`op`, the operator between each value.
-> Parsec b	a parser that parses alternating `p` and `op`, ending in a `p`, and applies their results right-associatively.

This combinator handles right-associative parsing, and the 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, x₁ through xₙ, are combined with the results of the ops, f₁ through fₙ, with right-associative application: f₁ x₁ (f₂ x₂ (...(fₙ₋₁ xₙ₋₁ xₙ)...)). 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 chainr1, this combinator allows the types of the operators to more accurately encode their associativity in their types. However, chainr1, in which a and b must match, allows for more flexibility to change the associativity.

infixn1 Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`.
-> Parsec a	`p`, the value to be parsed
-> Parsec (a -> a -> b)	`op`, the operator between each value.
-> Parsec b	a parser that parses `p`, `op` and then `p`, and applies the result of `op` to those of `p` in the same order.

This combinator handles non-associative parsing, and the application of, zero or one binary operators between one or two values.

First parse p. Then:

If this not is followed by an op, simply return p.
Otherwise, parse this op followed by a single p. Then ensure that this is not followed by a further op, to enforce non-associativity. The results of the ps, x and y, are combined with the result of op, f with the application f x y. 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. This combinator also fails if the second p is followed by another op.

Unary Operator Chains

These combinators allow for the chaining together, and application, of multiple prefix or postfix unary operators to a single value.

prefix Source #

Arguments

:: (a -> b)	`wrap` a function converting the value type `a` into the result type `b`
-> Parsec (b -> b)	`op`, the prefix operator to repeatedly parse before `p`.
-> Parsec a	`p`, the single value to be parsed
-> Parsec b	a parser that parses many `op`s, and a final `p`, and applies all of the results right-associatively.

This combinator handles right-assocative parsing, and application of, zero or more prefix unary operators to a single value.

First parse many repeated ops. When there are no more ops left to parse, parse a single p. The result of p, x, is applied first to wrap, and then to each of the results of the ops, f₁ through fₙ, such that fₙ is applied first and f₁ last: f₁ (f₂ (..(fₙ (wrap x))..)). 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.

postfix Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`
-> Parsec a	`p`, the single value to be parsed
-> Parsec (b -> b)	`op`, the postfix operator to repeatedly parse after `p`.
-> Parsec b	a parser that parses many `op`s, and a final `p`, and applies all of the results left-associatively.

This combinator handles left-assocative parsing, and application of, zero or more postfix unary operators to a single value.

First parse a single p. Then, parse many repeated ops. The result of p, x, is applied first to wrap, and then to each of the results of the ops, f₁ through fₙ, such that f₁ is applied first and fₙ last: fₙ( fₙ₋₁(..f₁ (wrap x)..)). 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.

Module Re-export

This should be removed.

infixl1 Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`.
-> Parsec a	`p`, the value to be parsed
-> Parsec (b -> a -> b)	`op`, the operator between each value.
-> Parsec b	a parser that parses alternating `p` and `op`, ending in a `p`, and applies their results left-associatively.

This combinator handles left-associative parsing, and the 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, x₁ through xₙ, are combined with the results of the ops, f₁ through fₙ₋₁, with left-associative application: fₙ₋₁ (fₙ₋₂ (..(f₁ x₁ x₂)..) xₙ₋₁) xₙ. 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 chainl1, this combinator allows the types of the operators to more accurately encode their associativity in their types. However, chainl1, in which a and b must match, allows for more flexibility to change the associativity.

infixr1 Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`.
-> Parsec a	`p`, the value to be parsed
-> Parsec (a -> b -> b)	`op`, the operator between each value.
-> Parsec b	a parser that parses alternating `p` and `op`, ending in a `p`, and applies their results right-associatively.

This combinator handles right-associative parsing, and the 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, x₁ through xₙ, are combined with the results of the ops, f₁ through fₙ, with right-associative application: f₁ x₁ (f₂ x₂ (...(fₙ₋₁ xₙ₋₁ xₙ)...)). 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 chainr1, this combinator allows the types of the operators to more accurately encode their associativity in their types. However, chainr1, in which a and b must match, allows for more flexibility to change the associativity.

infixn1 Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`.
-> Parsec a	`p`, the value to be parsed
-> Parsec (a -> a -> b)	`op`, the operator between each value.
-> Parsec b	a parser that parses `p`, `op` and then `p`, and applies the result of `op` to those of `p` in the same order.

This combinator handles non-associative parsing, and the application of, zero or one binary operators between one or two values.

First parse p. Then:

If this not is followed by an op, simply return p.
Otherwise, parse this op followed by a single p. Then ensure that this is not followed by a further op, to enforce non-associativity. The results of the ps, x and y, are combined with the result of op, f with the application f x y. 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. This combinator also fails if the second p is followed by another op.

prefix Source #

Arguments

:: (a -> b)	`wrap` a function converting the value type `a` into the result type `b`
-> Parsec (b -> b)	`op`, the prefix operator to repeatedly parse before `p`.
-> Parsec a	`p`, the single value to be parsed
-> Parsec b	a parser that parses many `op`s, and a final `p`, and applies all of the results right-associatively.

This combinator handles right-assocative parsing, and application of, zero or more prefix unary operators to a single value.

First parse many repeated ops. When there are no more ops left to parse, parse a single p. The result of p, x, is applied first to wrap, and then to each of the results of the ops, f₁ through fₙ, such that fₙ is applied first and f₁ last: f₁ (f₂ (..(fₙ (wrap x))..)). 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.

postfix Source #

Arguments

:: (a -> b)	a function converting the value type `a` into the result type `b`
-> Parsec a	`p`, the single value to be parsed
-> Parsec (b -> b)	`op`, the postfix operator to repeatedly parse after `p`.
-> Parsec b	a parser that parses many `op`s, and a final `p`, and applies all of the results left-associatively.

This combinator handles left-assocative parsing, and application of, zero or more postfix unary operators to a single value.

First parse a single p. Then, parse many repeated ops. The result of p, x, is applied first to wrap, and then to each of the results of the ops, f₁ through fₙ, such that f₁ is applied first and fₙ last: fₙ( fₙ₋₁(..f₁ (wrap x)..)). 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.