Safe Haskell	None
Language	Haskell2010

Text.ParserCombinators.Incremental

Contents

The Parser type
Using a Parser
Parser primitives
- Character primitives
Parser combinators
Utilities

Description

This module defines incremental parsers.

The exported Parser type can provide partial parsing results from partial input, as long as the output is a Monoid. Construct a parser using the primitives and combinators, supply it with input using functions feed and feedEof, and extract the parsed output using results.

Implementation is based on Brzozowski derivatives.

Synopsis

The Parser type

data Parser a s r Source

The central parser type. Its first parameter is the input monoid, the second the output.

Instances

Monoid s => Alternative (Parser LeftBiasedLocal s)	Left-biased choice. The right parser is used only if the left one utterly fails.
Monoid s => Alternative (Parser Symmetric s)	The symmetric version of the `<\|>` choice combinator.
Monoid s => Monad (Parser a s)	Usage of `>>=` destroys the incrementality of its left argument's parsing results, but `>>` is safe to use.
Monoid s => Functor (Parser a s)	Usage of `fmap` destroys the incrementality of parsing results, if you need it use `mapIncremental` instead.
Monoid s => MonadPlus (Parser LeftBiasedLocal s)	The `MonadPlus` instances are the same as the `Alternative` instances.
Monoid s => MonadPlus (Parser Symmetric s)	The `MonadPlus` instances are the same as the `Alternative` instances.
Monoid s => Applicative (Parser a s)	The `<>` combinator requires its both arguments to provide complete parsing results, takeWhile `>` and `<*` preserve the incremental results.
(Alternative (Parser a s), Monoid s) => MonoidAlternative (Parser a s)
Monoid s => MonoidApplicative (Parser a s)
(Monoid s, Monoid r) => Monoid (Parser a s r)	Two parsers can be sequentially joined.

Using a Parser

feed :: Monoid s => s -> Parser a s r -> Parser a s r Source

Feeds a chunk of the input to the parser.

feedEof :: Monoid s => Parser a s r -> Parser a s r Source

Signals the end of the input.

inspect :: Parser a s r -> ([(r, s)], Maybe (Maybe (r -> r), Parser a s r)) Source

Like results, but more general: doesn't assume that the result type is a Monoid.

results :: Monoid r => Parser a s r -> ([(r, s)], Maybe (r, Parser a s r)) Source

Extracts all available parsing results from a Parser. The first component of the result pair is a list of complete results together with the unconsumed remainder of the input. If the parsing can continue further, the second component of the pair provides the partial result prefix together with the parser for the rest of the input.

completeResults :: Parser a s r -> [(r, s)] Source

Like results, but returns only the complete results with the corresponding unconsumed inputs.

resultPrefix :: Monoid r => Parser a s r -> (r, Parser a s r) Source

Like results, but returns only the partial result prefix.

Parser primitives

failure :: Parser a s r Source

more :: (s -> Parser a s r) -> Parser a s r Source

eof :: (MonoidNull s, Monoid r) => Parser a s r Source

A parser that fails on any input and succeeds at its end.

anyToken :: FactorialMonoid s => Parser a s s Source

A parser that accepts any single input atom.

token :: (Eq s, FactorialMonoid s) => s -> Parser a s s Source

A parser that accepts a specific input atom.

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser a s s Source

A parser that accepts an input atom only if it satisfies the given predicate.

acceptAll :: Monoid s => Parser a s s Source

A parser that accepts all input.

string :: (LeftReductiveMonoid s, MonoidNull s) => s -> Parser a s s Source

A parser that consumes and returns the given prefix of the input.

takeWhile :: (FactorialMonoid s, MonoidNull s) => (s -> Bool) -> Parser a s s Source

A parser accepting the longest sequence of input atoms that match the given predicate; an optimized version of 'concatMany . satisfy'.

takeWhile1 :: (FactorialMonoid s, MonoidNull s) => (s -> Bool) -> Parser a s s Source

A parser accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized version of 'concatSome . satisfy'.

Character primitives

satisfyChar :: TextualMonoid s => (Char -> Bool) -> Parser a s s Source

Specialization of satisfy on TextualMonoid inputs, accepting an input character only if it satisfies the given predicate.

takeCharsWhile :: (TextualMonoid s, MonoidNull s) => (Char -> Bool) -> Parser a s s Source

Specialization of takeWhile on TextualMonoid inputs, accepting the longest sequence of input characters that match the given predicate; an optimized version of 'concatMany . satisfyChar'.

takeCharsWhile1 :: (TextualMonoid s, MonoidNull s) => (Char -> Bool) -> Parser a s s Source

Specialization of takeWhile1 on TextualMonoid inputs, accepting the longest non-empty sequence of input atoms that match the given predicate; an optimized version of 'concatSome . satisfyChar'.

Parser combinators

count :: (Monoid s, Monoid r) => Int -> Parser a s r -> Parser a s r Source

Accepts the given number of occurrences of the argument parser.

skip :: (Monoid s, Monoid r) => Parser a s r' -> Parser a s r Source

Discards the results of the argument parser.

moptional :: (MonoidAlternative f, Monoid a) => f a -> f a Source

Like optional, but restricted to Monoid results.

concatMany :: (MonoidAlternative f, Monoid a) => f a -> f a Source

Zero or more argument occurrences like many, but concatenated.

concatSome :: (MonoidAlternative f, Monoid a) => f a -> f a Source

One or more argument occurrences like some, but concatenated.

manyTill :: (Alternative (Parser a s), Monoid s, Monoid r) => Parser a s r -> Parser a s r' -> Parser a s r Source

Repeats matching the first argument until the second one succeeds.

mapType :: (Parser a s r -> Parser b s r) -> Parser a s r -> Parser b s r Source

mapIncremental :: (Monoid s, Monoid a, Monoid b) => (a -> b) -> Parser p s a -> Parser p s b Source

Like fmap, but capable of mapping partial results, being restricted to Monoid types only.

(<||>) :: Parser a s r -> Parser a s r -> Parser a s r infixl 3 Source

(<<|>) :: Monoid s => Parser a s r -> Parser a s r -> Parser a s r infixl 3 Source

(><) :: (MonoidApplicative f, Monoid a) => f a -> f a -> f a Source

Lifted and potentially optimized monoid mappend operation from the parameter type.

lookAhead :: Monoid s => Parser a s r -> Parser a s r Source

Behaves like the argument parser, but without consuming any input.

notFollowedBy :: (Monoid s, Monoid r) => Parser a s r' -> Parser a s r Source

Does not consume any input; succeeds (with mempty result) iff the argument parser fails.

and :: (Monoid s, Monoid r1, Monoid r2) => Parser a s r1 -> Parser a s r2 -> Parser a s (r1, r2) Source

Parallel parser conjunction: the combined parser keeps accepting input as long as both arguments do.

andThen :: (Monoid s, Monoid r1, Monoid r2) => Parser a s r1 -> Parser a s r2 -> Parser a s (r1, r2) Source

A sequence parser that preserves incremental results, otherwise equivalent to liftA2 (,)

Utilities

isInfallible :: Parser a s r -> Bool Source

showWith :: (Monoid s, Monoid r, Show s) => ((s -> Parser a s r) -> String) -> (r -> String) -> Parser a s r -> String Source