Text.Parsec.Combinator

parsec-3.1.9: 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 | portable
Safe Haskell | Safe
Language | Haskell98

Text.Parsec.Combinator

Description

Commonly used generic combinators

Synopsis

- choice :: Stream s m t => [ParsecT s u m a] -> ParsecT s u m a
- count :: Stream s m t => Int -> ParsecT s u m a -> ParsecT s u m [a]
- between :: Stream s m t => ParsecT s u m open -> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a
- option :: Stream s m t => a -> ParsecT s u m a -> ParsecT s u m a
- optionMaybe :: Stream s m t => ParsecT s u m a -> ParsecT s u m (Maybe a)
- optional :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()
- skipMany1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()
- many1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m [a]
- sepBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
- sepBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
- endBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
- endBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
- sepEndBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
- sepEndBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]
- chainl :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
- chainl1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
- chainr :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a
- chainr1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a
- eof :: (Stream s m t, Show t) => ParsecT s u m ()
- notFollowedBy :: (Stream s m t, Show a) => ParsecT s u m a -> ParsecT s u m ()
- manyTill :: Stream s m t => ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]
- lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a
- anyToken :: (Stream s m t, Show t) => ParsecT s u m t

# Documentation

choice :: Stream s m t => [ParsecT s u m a] -> ParsecT s u m a

`choice ps` tries to apply the parsers in the list `ps` in order, until one of them succeeds. Returns the value of the succeeding parser.

count :: Stream s m t => Int -> ParsecT s u m a -> ParsecT s u m [a]

`count n p` parses `n` occurrences of `p`. If `n` is smaller or equal to zero, the parser equals to `return []`. Returns a list of `n` values returned by `p`.

between :: Stream s m t => ParsecT s u m open -> ParsecT s u m close -> ParsecT s u m a -> ParsecT s u m a

`between open close p` parses `open`, followed by `p` and `close`. Returns the value returned by `p`.

     braces  = between (symbol "{") (symbol "}")

option :: Stream s m t => a -> ParsecT s u m a -> ParsecT s u m a

`option x p` tries to apply parser `p`. If `p` fails without consuming input, it returns the value `x`, otherwise the value returned by `p`.

     priority  = option 0 (do{ d <- digit
                             ; return (digitToInt d)
                             })

optionMaybe :: Stream s m t => ParsecT s u m a -> ParsecT s u m (Maybe a)

`optionMaybe p` tries to apply parser `p`. If `p` fails without consuming input, it return `Nothing`, otherwise it returns `Just` the value returned by `p`.

optional :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()

`optional p` tries to apply parser `p`. It will parse `p` or nothing. It only fails if `p` fails after consuming input. It discards the result of `p`.

skipMany1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m ()

`skipMany1 p` applies the parser `p` one or more times, skipping its result.

many1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m [a]

`many1 p` applies the parser `p` one or more times. Returns a list of the returned values of `p`.

     word  = many1 letter

sepBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]

`sepBy p sep` parses zero or more occurrences of `p`, separated by `sep`. Returns a list of values returned by `p`.

     commaSep p  = p `sepBy` (symbol ",")

sepBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]

`sepBy1 p sep` parses one or more occurrences of `p`, separated by `sep`. Returns a list of values returned by `p`.

endBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]

`endBy p sep` parses zero or more occurrences of `p`, separated and ended by `sep`. Returns a list of values returned by `p`.

      cStatements  = cStatement `endBy` semi

endBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]

`endBy1 p sep` parses one or more occurrences of `p`, separated and ended by `sep`. Returns a list of values returned by `p`.

sepEndBy :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]

`sepEndBy p sep` parses zero or more occurrences of `p`, separated and optionally ended by `sep`, ie. haskell style statements. Returns a list of values returned by `p`.

     haskellStatements  = haskellStatement `sepEndBy` semi

sepEndBy1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m sep -> ParsecT s u m [a]

`sepEndBy1 p sep` parses one or more occurrences of `p`, separated and optionally ended by `sep`. Returns a list of values returned by `p`.

chainl :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a

`chainl p op x` parses zero or more occurrences of `p`, separated by `op`. Returns a value obtained by a left associative application of all functions returned by `op` to the values returned by `p`. If there are zero occurrences of `p`, the value `x` is returned.

chainl1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a

`chainl1 p op x` parses one or more occurrences of `p`, separated by `op` Returns a value obtained by a left associative application of all functions returned by `op` to the values returned by `p`. . This parser can for example be used to eliminate left recursion which typically occurs in expression grammars.

     expr    = term   `chainl1` addop
     term    = factor `chainl1` mulop
     factor  = parens expr <|> integer

     mulop   =   do{ symbol "*"; return (*)   }
             <|> do{ symbol "/"; return (div) }

     addop   =   do{ symbol "+"; return (+) }
             <|> do{ symbol "-"; return (-) }

chainr :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> a -> ParsecT s u m a

`chainr p op x` parses zero or more occurrences of `p`, separated by `op` Returns a value obtained by a right associative application of all functions returned by `op` to the values returned by `p`. If there are no occurrences of `p`, the value `x` is returned.

chainr1 :: Stream s m t => ParsecT s u m a -> ParsecT s u m (a -> a -> a) -> ParsecT s u m a

`chainr1 p op x` parses one or more occurrences of |p|, separated by `op` Returns a value obtained by a right associative application of all functions returned by `op` to the values returned by `p`.

eof :: (Stream s m t, Show t) => ParsecT s u m ()

This parser only succeeds at the end of the input. This is not a primitive parser but it is defined using `notFollowedBy`.

     eof  = notFollowedBy anyToken <?> "end of input"

notFollowedBy :: (Stream s m t, Show a) => ParsecT s u m a -> ParsecT s u m ()

`notFollowedBy p` only succeeds when parser `p` fails. This parser does not consume any input. This parser can be used to implement the 'longest match' rule. For example, when recognizing keywords (for example `let`), we want to make sure that a keyword is not followed by a legal identifier character, in which case the keyword is actually an identifier (for example `lets`). We can program this behaviour as follows:

     keywordLet  = try (do{ string "let"
                          ; notFollowedBy alphaNum
                          })

manyTill :: Stream s m t => ParsecT s u m a -> ParsecT s u m end -> ParsecT s u m [a]

`manyTill p end` applies parser `p` zero or more times until parser `end` succeeds. Returns the list of values returned by `p`. This parser can be used to scan comments:

     simpleComment   = do{ string "<!--"
                         ; manyTill anyChar (try (string "-->"))
                         }

Note the overlapping parsers `anyChar` and `string "-->"`, and therefore the use of the `try` combinator.

lookAhead :: Stream s m t => ParsecT s u m a -> ParsecT s u m a

`lookAhead p` parses `p` without consuming any input.

If `p` fails and consumes some input, so does `lookAhead`. Combine with `try` if this is undesirable.

anyToken :: (Stream s m t, Show t) => ParsecT s u m t

The parser `anyToken` accepts any kind of token. It is for example used to implement `eof`. Returns the accepted token.