|
Text.ParserCombinators.Poly |
|
|
|
|
|
Synopsis |
|
|
|
|
The Parser datatype
|
|
|
The Parser datatype is a fairly generic parsing monad with error
reporting. It can be used for arbitrary token types, not just
String input. (If you require a running state, use module PolyState
instead)
| Constructors | P ([t] -> (EitherE String a, [t])) | |
| Instances | |
|
|
runParser :: Parser t a -> [t] -> (Either String a, [t]) | Source |
|
Apply a parser to an input token sequence.
|
|
|
When a simple fail is not strong enough, use failBad for emphasis.
An emphasised (severe) error can propagate out through choice operators.
|
|
|
Commit is a way of raising the severity of any errors found within
its argument. Used in the middle of a parser definition, it means that
any operations prior to commitment fail softly, but after commitment,
they fail hard.
|
|
Combinators:
|
|
Primitives
|
|
|
One token
|
|
|
One token satifying a predicate
|
|
|
Apply a parsed function to a parsed value
|
|
|
x discard y parses both x and y, but discards the result of y
|
|
Error-handling
|
|
|
p adjustErr f applies the transformation f to any error message
generated in p, having no effect if p succeeds.
|
|
|
adjustErrBad is just like adjustErr except it also raises the
severity of the error.
|
|
indent :: Int -> String -> String | Source |
|
Helper for formatting error messages: indents all lines by a fixed amount.
|
|
Choices
|
|
|
p onFail q means parse p unless p fails in which case parse q instead.
Can be chained together to give multiple attempts to parse something.
(Note that q could itself be a failing parser, e.g. to change the error
message from that defined in p to something different.)
However, a *severe* failure in p cannot be ignored.
|
|
|
Parse the first alternative in the list that succeeds.
|
|
|
Parse the first alternative that succeeds, but if none succeed,
report only the severe errors, and if none of those, then report
all the soft errors.
|
|
|
optional indicates whether the parser succeeded through the Maybe type.
|
|
Sequences
|
|
|
'many p' parses a list of elements with individual parser p.
Cannot fail, since an empty list is a valid return value.
|
|
|
Parse a non-empty list of items.
|
|
|
Parse a list of items separated by discarded junk.
|
|
|
Parse a non-empty list of items separated by discarded junk.
|
|
|
Parse a list of items, discarding the start, end, and separator
items.
|
|
|
Parse a bracketed item, discarding the brackets.
|
|
|
'manyFinally e t' parses a possibly-empty sequence of e's,
terminated by a t. Any parse failures could be due either to
a badly-formed terminator or a badly-formed element, so raise
both possible errors.
|
|
re-parsing
|
|
|
Push some tokens back onto the front of the input stream and reparse.
This is useful e.g. for recursively expanding macros. When the
user-parser recognises a macro use, it can lookup the macro
expansion from the parse state, lex it, and then stuff the
lexed expansion back down into the parser.
|
|
Produced by Haddock version 0.8 |