parsec-3.1.11: Monadic parser combinators

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 | Haskell98

Text.Parsec.Expr

Description

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

Synopsis

- data Assoc
  - = AssocNone
  - | AssocLeft
  - | AssocRight
- data Operator s u m a
  - = Infix (ParsecT s u m (a -> a -> a)) Assoc
  - | Prefix (ParsecT s u m (a -> a))
  - | Postfix (ParsecT s u m (a -> 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

data Assoc Source #

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

Constructors

AssocNone |
AssocLeft |
AssocRight |

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.

Constructors

Infix (ParsecT s u m (a -> a -> a)) Assoc |
Prefix (ParsecT s u m (a -> a)) |
Postfix (ParsecT s u m (a -> a)) |

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 })