Text.ParserCombinators.Poly.Lazy

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

P ([t] -> (Either String a, [t]))

Instances

Monad (Parser t)

Functor (Parser t)

PolyParse (Parser t)

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

next :: Parser t t

satisfy :: (t -> Bool) -> Parser t t

Next token

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