- newtype Parser a = P (ByteString -> Result ByteString a)
- data Result z a
- runParser :: Parser a -> ByteString -> (Either String a, ByteString)
- next :: Parser Char
- eof :: Parser ()
- satisfy :: (Char -> Bool) -> Parser Char
- onFail :: Parser a -> Parser a -> Parser a
- manySatisfy :: (Char -> Bool) -> Parser ByteString
- many1Satisfy :: (Char -> Bool) -> Parser ByteString
- reparse :: ByteString -> Parser ()
- module Text.ParserCombinators.Poly.Base
The Parser datatype
Parser datatype is a specialised parsing monad with error
reporting. Whereas the standard version can be used for arbitrary
token types, this version is specialised to ByteString input only.
A return type like Either, that distinguishes not only between right and wrong answers, but also has commitment, so that a failure cannot be undone. This should only be used for writing very primitive parsers - really it is an internal detail of the library. The z type is the remaining unconsumed input.
Apply a parser to an input token sequence.
Return the next token if it satisfies the given predicate.
p 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.
Derived parsers (but implemented more efficiently)
manySatisfy p is a more efficient fused version of
many (satisfy p)
many1Satisfy p is a more efficient fused version of
many1 (satisfy p)
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.