|
documentation:
|
# det-parse
det-parse is a library of deterministic parser combinators. It is based on the
material presented in Frank Huch's functional programming lecture at Kiel
University. To use it, you build a `Parser a` using the provided combinators and
then apply it to a string using `parse`. The simplest parsers are provided by
the primitives `yield`, `failure`, `anyChar` and `check`.
`yield` always results in the given value, consuming no input. `yield 1` will
successfully parse the empty string to the value `1`. `failure` is a parser that
always fails. `anyChar` is a parser that consumes a single character and uses it
as the parse result. `check` takes a parser and a predicate on the result type
of the parser. From these, it builds a new parser that applies the existing
parser and succeeds only if the predicate holds for the parse result.
`char` and `word` build parsers for single characters and whole strings from
these primitives. `char 'c'` is a parser that consumes the single character `c`
and results in the unit value `()`. `word "hello"` consumes the string `hello`
and results in the unit value. `empty` is a parser that recognizes an empty
string and results in the unit value.
The operators `*>` and `<*` are provided to combine parsers into more comples
ones. `*>` applies two parsers and returns the result of the second one if both
were successful. `char 'a' *> yield 1` is successful if applied to the string
`a` and results in the value `1`. `<*` applies two parsers in the same order,
i.e. left to right, but returns the result of the first one.
`<|>` combines two parsers by applying them both. If the first one is
successful, it returns its result. If it is not, but the second one is, then it
returns the result of the second one. If both are unsuccessful, the combined
parser is unsuccessful as well. The parser
`char 'a' *> yield 1 <|> char 'b' *> yield 2` parses the string `a` to
the value `1` and the string `b` to the value `2`. `<!>` works similarly to
`<|>`, but does not backtrack. That is, it only tries the second parser if the
first one was unsuccessful, and only on the remaining input. It can be used if
the alternatives do not overlap. The above example would also work if `<|>` were
replaced by `<!>`, while `word "ab" *> yield 1 <!> word "abc" *> yield 2` would
fail to parse `abc` into the value `2` since the first alternative has already
consumed `ab`.
`<$>` builds a new parser from an existing parser by applying a function to the
result of that parser. For example, `(+ 1) <$> (char 'a' *> yield 1)` is a
parser that parses the string `a` into the value `2`.
`<*> :: Parser (a -> b) -> Parser a -> Parser b ` combines two parsers, one that
results in a function from `a` to `b`, and one that results in an `a` value. It
applies the parsers in order and then applies the function result of the first
parser to the value result of the second parser.
`many :: Parser a -> Parser [a]` builds a parser that parses whatever the
original parser parses arbitrarily many times. `some` is similar, but requires
that the original parser succeed at least once. Applying
`many (char 'a' *> yield 1)` to the string `aaaa` results in the value
`[1,1,1,1]`.
|