parsers-0.11.0.2: Parsing combinators

Copyright (c) Edward Kmett 2011-2012 BSD3 ekmett@gmail.com experimental non-portable None Haskell2010

Text.Parser.Combinators

Contents

Description

Alternative parser combinators

Synopsis

# Parsing Combinators

choice :: Alternative m => [m a] -> m a Source

`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.

option :: Alternative m => a -> m a -> m a Source

`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 (digitToInt <\$> digit)`

optional :: Alternative f => f a -> f (Maybe a)

One or none.

skipOptional :: Alternative m => m a -> m () Source

`skipOptional 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`. (Plays the role of parsec's optional, which conflicts with Applicative's optional)

between :: Applicative m => m bra -> m ket -> m a -> m a Source

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

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

some :: Alternative f => forall a. f a -> f [a]

One or more.

many :: Alternative f => forall a. f a -> f [a]

Zero or more.

sepBy :: Alternative m => m a -> m sep -> m [a] Source

`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 :: Alternative m => m a -> m sep -> m [a] Source

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

sepEndBy1 :: Alternative m => m a -> m sep -> m [a] Source

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

sepEndBy :: Alternative m => m a -> m sep -> m [a] Source

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

endBy1 :: Alternative m => m a -> m sep -> m [a] Source

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

endBy :: Alternative m => m a -> m sep -> m [a] Source

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

`  cStatements  = cStatement `endBy` semi`

count :: Applicative m => Int -> m a -> m [a] Source

`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`.

chainl :: Alternative m => m a -> m (a -> a -> a) -> a -> m a Source

`chainl p op x` parser 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.

chainr :: Alternative m => m a -> m (a -> a -> a) -> a -> m a Source

`chainr p op x` parser 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.

chainl1 :: Alternative m => m a -> m (a -> a -> a) -> m a Source

`chainl1 p op x` parser 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  = (*) <\$ symbol "*"
<|> div <\$ symbol "/"

addop  = (+) <\$ symbol "+"
<|> (-) <\$ symbol "-"```

chainr1 :: Alternative m => m a -> m (a -> a -> a) -> m a Source

`chainr1 p op x` parser 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`.

manyTill :: Alternative m => m a -> m end -> m [a] Source

`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.

# Parsing Class

class Alternative m => Parsing m where Source

Additional functionality needed to describe parsers independent of input type.

Minimal complete definition

Methods

try :: m a -> m a Source

Take a parser that may consume input, and on failure, go back to where we started and fail as if we didn't consume input.

(<?>) :: m a -> String -> m a infixr 0 Source

Give a parser a name

skipMany :: m a -> m () Source

A version of many that discards its input. Specialized because it can often be implemented more cheaply.

skipSome :: m a -> m () Source

`skipSome p` applies the parser `p` one or more times, skipping its result. (aka skipMany1 in parsec)

unexpected :: String -> m a Source

Used to emit an error on an unexpected token

eof :: m () Source

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

` eof  = notFollowedBy anyChar <?> "end of input"`

notFollowedBy :: (Monad m, Show a) => m a -> m () Source

`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 \$ string "let" <* notFollowedBy alphaNum`

Instances

 Parsing ReadP Chunk t => Parsing (Parser t) (Parsing m, Monad m) => Parsing (IdentityT m) Parsing m => Parsing (Unlined m) Parsing m => Parsing (Unspaced m) Parsing m => Parsing (Unhighlighted m) (Parsing m, MonadPlus m) => Parsing (ReaderT e m) (Parsing m, MonadPlus m) => Parsing (StateT s m) (Parsing m, MonadPlus m) => Parsing (StateT s m) (Parsing m, MonadPlus m, Monoid w) => Parsing (WriterT w m) (Parsing m, MonadPlus m, Monoid w) => Parsing (WriterT w m) (Stream s m t, Show t) => Parsing (ParsecT s u m) (Parsing m, MonadPlus m, Monoid w) => Parsing (RWST r w s m) (Parsing m, MonadPlus m, Monoid w) => Parsing (RWST r w s m)