Copyright | (c) Daan Leijen 1999-2001 (c) Paolo Martini 2007 |
---|---|

License | BSD-style (see the LICENSE file) |

Maintainer | derek.a.elkins@gmail.com |

Stability | provisional |

Portability | non-portable |

Safe Haskell | Safe |

Language | Haskell2010 |

A helper module to parse "expressions". Builds a parser given a table of operators and associativities.

## Synopsis

- data Assoc
- data Operator s u m a
- type OperatorTable s u m a = [[Operator s u m a]]
- buildExpressionParser :: Stream s m t => OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a

# Documentation

This data type specifies the associativity of operators: left, right or none.

data Operator s u m a Source #

This data type specifies operators that work on values of type `a`

.
An operator is either binary infix or unary prefix or postfix. A
binary operator has also an associated associativity.

type OperatorTable s u m a = [[Operator s u m a]] Source #

An `OperatorTable s u m a`

is a list of `Operator s u m a`

lists. The list is ordered in descending
precedence. All operators in one list have the same precedence (but
may have a different associativity).

buildExpressionParser :: Stream s m t => OperatorTable s u m a -> ParsecT s u m a -> ParsecT s u m a Source #

`buildExpressionParser table term`

builds an expression parser for
terms `term`

with operators from `table`

, taking the associativity
and precedence specified in `table`

into account. Prefix and postfix
operators of the same precedence can only occur once (i.e. `--2`

is
not allowed if `-`

is prefix negate). Prefix and postfix operators
of the same precedence associate to the left (i.e. if `++`

is
postfix increment, than `-2++`

equals `-1`

, not `-3`

).

The `buildExpressionParser`

takes care of all the complexity
involved in building expression parser. Here is an example of an
expression parser that handles prefix signs, postfix increment and
basic arithmetic.

expr = buildExpressionParser table term <?> "expression" term = parens expr <|> natural <?> "simple expression" table = [ [prefix "-" negate, prefix "+" id ] , [postfix "++" (+1)] , [binary "*" (*) AssocLeft, binary "/" (div) AssocLeft ] , [binary "+" (+) AssocLeft, binary "-" (-) AssocLeft ] ] binary name fun assoc = Infix (do{ reservedOp name; return fun }) assoc prefix name fun = Prefix (do{ reservedOp name; return fun }) postfix name fun = Postfix (do{ reservedOp name; return fun })