 | polyparse-1.1: A variety of alternative parser combinator libraries. | Contents | Index |
|
| Text.ParserCombinators.Poly.Lazy |
|
|
|
|
|
| Synopsis |
|
|
|
|
| The Parser datatype.
|
|
| When applied, these parsers do not return explicit failure.
An exception is
raised instead. This allows partial results to be returned
before a full parse is complete.
One of the key ways to ensure that your parser is properly lazy,
is to parse the initial portion of text returning a function, then
use the apply combinator to build the final value.
|
|
| newtype Parser t a |
| 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 PolyStateLazy
instead.)
| | Constructors | |  Instances | |
|
|
| runParser :: Parser t a -> [t] -> (a, [t]) |
| Apply a parser to an input token sequence. The parser cannot return
an error value explicitly, so errors raise an exception. Thus, results
can be partial (lazily constructed, but containing undefined).
|
|
| basic parsers
|
|
| satisfy :: (t -> Bool) -> Parser t t |
| One token satifying a predicate
|
|
| manyFinally :: Parser t a -> Parser t z -> Parser t [a] |
| '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
|
|
| reparse :: [t] -> Parser t () |
| 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.
|
|
| Re-export all more general combinators
|
|
| module Text.ParserCombinators.Poly.Base |
|
| Produced by Haddock version 0.8 |