Text.ParserCombinators.Poly.Base
 Contents The PolyParse class Combinators general to all parser types. Simple combinators Error-handling Choices Sequences
Synopsis
class (Functor p, Monad p) => PolyParse p where
 commit :: p a -> p a adjustErr :: p a -> (String -> String) -> p a onFail :: p a -> p a -> p a oneOf' :: [(String, p a)] -> p a apply :: p (a -> b) -> p a -> p b
discard :: PolyParse p => p a -> p b -> p a
failBad :: PolyParse p => String -> p a
adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a
indent :: Int -> String -> String
oneOf :: PolyParse p => [p a] -> p a
optional :: PolyParse p => p a -> p (Maybe a)
exactly :: PolyParse p => Int -> p a -> p [a]
many :: PolyParse p => p a -> p [a]
many1 :: PolyParse p => p a -> p [a]
sepBy :: PolyParse p => p a -> p sep -> p [a]
sepBy1 :: PolyParse p => p a -> p sep -> p [a]
bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a]
bracket :: PolyParse p => p bra -> p ket -> p a -> p a
manyFinally :: PolyParse p => p a -> p z -> p [a]
The PolyParse class
 class (Functor p, Monad p) => PolyParse p where Source

The PolyParse class is an abstraction over all the current concrete representations of monadic parser combinators in this package. The common feature is two-level error-handling. Some primitives must be implemented specific to each parser type (e.g. depending on whether the parser has a running state, or whether it is lazy). But given those primitives, large numbers of combinators do not depend any further on the internal structure of the particular parser.

There are two additional basic combinators that we expect to be implemented afresh for every concrete type, but which (for technical reasons) cannot be class methods. They are next and satisfy.

Methods
 commit :: p a -> p a Source
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.
 adjustErr :: p a -> (String -> String) -> p a Source
p adjustErr f applies the transformation f to any error message generated in p, having no effect if p succeeds.
 onFail :: p a -> p a -> p a Source
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.
 oneOf' :: [(String, p a)] -> p a Source
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.
 apply :: p (a -> b) -> p a -> p b Source
Apply a parsed function to a parsed value. Rather like ordinary function application lifted into parsers. Instances
 PolyParse Parser PolyParse (Parser t) PolyParse (Parser t) PolyParse (Parser s t) PolyParse (Parser s t)
Combinators general to all parser types.
Simple combinators
 discard :: PolyParse p => p a -> p b -> p a Source
x discard y parses both x and y, but discards the result of y. Rather like const lifted into parsers.
Error-handling
 failBad :: PolyParse p => String -> p a Source
When a simple fail is not strong enough, use failBad for emphasis. An emphasised (severe) error cannot be overridden by choice operators.
 adjustErrBad :: PolyParse p => p a -> (String -> String) -> p a Source
 indent :: Int -> String -> String Source
Helper for formatting error messages: indents all lines by a fixed amount.
Choices
 oneOf :: PolyParse p => [p a] -> p a Source
Parse the first alternative in the list that succeeds.
 optional :: PolyParse p => p a -> p (Maybe a) Source
optional indicates whether the parser succeeded through the Maybe type.
Sequences
 exactly :: PolyParse p => Int -> p a -> p [a] Source
'exactly n p' parses precisely n items, using the parser p, in sequence.
 many :: PolyParse p => p a -> p [a] Source
'many p' parses a list of elements with individual parser p. Cannot fail, since an empty list is a valid return value.
 many1 :: PolyParse p => p a -> p [a] Source
Parse a non-empty list of items.
 sepBy :: PolyParse p => p a -> p sep -> p [a] Source
Parse a list of items separated by discarded junk.
 sepBy1 :: PolyParse p => p a -> p sep -> p [a] Source
Parse a non-empty list of items separated by discarded junk.
 bracketSep :: PolyParse p => p bra -> p sep -> p ket -> p a -> p [a] Source
Parse a list of items, discarding the start, end, and separator items.
 bracket :: PolyParse p => p bra -> p ket -> p a -> p a Source
Parse a bracketed item, discarding the brackets.
 manyFinally :: PolyParse p => p a -> p z -> p [a] Source
'manyFinally e t' parses a possibly-empty sequence of e's, terminated by a t. The final t is discarded. Any parse failures could be due either to a badly-formed terminator or a badly-formed element, so it raises both possible errors.