Text.ParserCombinators.Incremental.Symmetric

This module defines parsing combinators for incremental parsers with symmetric choice.

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.

Documentation

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

Like optional, but restricted to Monoid results.

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

Zero or more argument occurrences like many, but concatenated.

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

One or more argument occurrences like some, but concatenated.

(><) :: (MonoidApplicative f, Semigroup a) => f a -> f a -> f a infixl 5

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

(+<*>) :: MonoidApplicative f => f (a -> a) -> f a -> f a infixl 4

A variant of the Applicative's <*> operator specialized for endomorphic functions.

feed :: Monoid s => s -> Parser t s r -> Parser t s r

Feeds a chunk of the input to the parser.

feedEof :: Monoid s => Parser t s r -> Parser t s r

Signals the end of the input.

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

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.

inspect :: Parser t s r -> Either String ([(r, s)], Maybe (Maybe (r -> r), Parser t s r))

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

completeResults :: Monoid s => Parser t s r -> [(r, s)]

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

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

Like results, but returns only the partial result prefix.

failure :: Parser t s r

(<?>) :: Monoid s => Parser t s r -> String -> Parser t s r infix 0

Name a parser for error reporting in case it fails.

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

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

defaultMany :: (Monoid s, Alternative (Parser t s)) => Parser t s r -> Parser t s [r]

defaultSome :: (Monoid s, Alternative (Parser t s)) => Parser t s r -> Parser t s [r]

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

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

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

lookAhead :: Monoid s => Parser t s r -> Parser t s r

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

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

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

record :: (Traversable g, Applicative m, Monoid s) => g (Parser t s) -> Parser t s (g m)

Combine a record of parsers into a record parser.

isInfallible :: Parser t s r -> Bool

mapType :: (forall a. Parser t s a -> Parser b s a) -> Parser t s r -> Parser b s r

Modifies the parser type

mapInput :: (Monoid s, Monoid s') => (s -> s') -> (s' -> s) -> Parser t s r -> Parser t s' r

Converts a parser accepting one input type to another. The argument functions forth and back must be inverses of each other and they must distribute through <>:

f (s1 <> s2) == f s1 <> f s2

mapMaybeInput :: (Monoid s, Monoid s') => (s -> Maybe s') -> (s' -> Maybe s) -> Parser t s r -> Parser t s' r

Converts a parser accepting one input type to another, just like 'mapMaybeInput except the two argument functions can demand more input by returning Nothing. If 'mapMaybeInput is defined for the two input inputs, then

mapInput f g == mapMaybeInput (Just . f) (Just . g)

more :: (s -> Parser t s r) -> Parser t s r

eof :: (MonoidNull s, Monoid r, Semigroup r) => Parser t s r

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

anyToken :: FactorialMonoid s => Parser t s s

A parser that accepts any single input atom.

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

A parser that accepts a specific input atom.

satisfy :: FactorialMonoid s => (s -> Bool) -> Parser t s s

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

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

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

string :: (LeftReductiveMonoid s, MonoidNull s, Semigroup s) => s -> Parser t s s

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

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

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 t s s

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

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

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 t s s

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'.

count :: (Monoid s, Monoid r, Semigroup r) => Int -> Parser t s r -> Parser t s r

Accepts the given number of occurrences of the argument parser.

skip :: (Monoid s, Monoid r, Semigroup r) => Parser t s r' -> Parser t s r

Discards the results of the argument parser.

manyTill :: (Monoid s, Monoid r, Semigroup r) => Parser t s r -> Parser t s r' -> Parser t s r

Repeats matching the first argument until the second one succeeds.

acceptAll :: (Semigroup s, Monoid s) => Parser t s s

A parser that accepts and consumes all input.

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

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

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

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

type Parser = Parser Symmetric

data Symmetric

An empty type to specialize Parser for the symmetric Alternative instance.

Instances

Monoid s => Alternative (Parser Symmetric s)

The symmetric version of the <|> choice combinator.

Defined in Text.ParserCombinators.Incremental.Symmetric

Methods

empty :: Parser Symmetric s a

(<|>) :: Parser Symmetric s a -> Parser Symmetric s a -> Parser Symmetric s a

some :: Parser Symmetric s a -> Parser Symmetric s [a]

many :: Parser Symmetric s a -> Parser Symmetric s [a]

Monoid s => MonadPlus (Parser Symmetric s)

The MonadPlus instances are the same as the Alternative instances.

Defined in Text.ParserCombinators.Incremental.Symmetric

Methods

mzero :: Parser Symmetric s a

mplus :: Parser Symmetric s a -> Parser Symmetric s a -> Parser Symmetric s a

allOf :: Parser s r -> Parser a s r