- newtype Parser t a = P ([t] -> (EitherE String a, [t]))
- runParser :: Parser t a -> [t] -> (Either String a, [t])
- failBad :: String -> Parser t a
- commit :: Parser t a -> Parser t a
- next :: Parser t t
- satisfy :: (t -> Bool) -> Parser t t
- apply :: Parser t (a -> b) -> Parser t a -> Parser t b
- discard :: Parser t a -> Parser t b -> Parser t a
- adjustErr :: Parser t a -> (String -> String) -> Parser t a
- adjustErrBad :: Parser t a -> (String -> String) -> Parser t a
- indent :: Int -> String -> String
- onFail :: Parser t a -> Parser t a -> Parser t a
- oneOf :: [Parser t a] -> Parser t a
- oneOf' :: [(String, Parser t a)] -> Parser t a
- optional :: Parser t a -> Parser t (Maybe a)
- many :: Parser t a -> Parser t [a]
- many1 :: Parser t a -> Parser t [a]
- sepBy :: Parser t a -> Parser t sep -> Parser t [a]
- sepBy1 :: Parser t a -> Parser t sep -> Parser t [a]
- bracketSep :: Parser t bra -> Parser t sep -> Parser t ket -> Parser t a -> Parser t [a]
- bracket :: Parser t bra -> Parser t ket -> Parser t a -> Parser t a
- manyFinally :: Parser t a -> Parser t z -> Parser t [a]
- reparse :: [t] -> Parser t ()
The Parser datatype
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
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.
Apply a parsed function to a parsed value
x parses both x and y, but discards the result of y
p applies the transformation
f to any error message
p, having no effect if
adjustErrBad is just like
adjustErr except it also raises the
severity of the error.
Helper for formatting error messages: indents all lines by a fixed amount.
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.
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.
'many p' parses a list of elements with individual parser p. Cannot fail, since an empty list is a valid return value.
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.
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.