This module contains the additional data types, instance definitions and functions to run parsers in an interleaved way. If all the interleaved parsers recognise a single connected piece of the input text this incorporates the permutation parsers. For some examples see the module Text.ParserCombinators.UU.Demo.MergeAndPermute.
- data Gram f a = Gram [Alt f a] (Maybe a)
- data Alt f a
- mkGram :: P t a -> Gram (P t) a
- (<||>) :: Functor f => Gram f (b -> a) -> Gram f b -> Gram f a
- (<<||>) :: Functor f => Gram f (b -> a) -> Gram f b -> Gram f a
- mkParserM :: (Monad f, Applicative f, ExtAlternative f) => Gram f a -> f a
- mkParserS :: (Monad f, Applicative f, ExtAlternative f) => f b -> Gram f a -> f a
- pmMany :: Functor f => Gram f a -> Gram f [a]
The data type
Since we want to get access to the individual parsers which recognise a consecutive piece of the input text we
define a new data type, which lifts the underlying parsers to the grammatical level, so they can be transformed, manipulated, and run in a piecewise way.
Gram is defined in such a way that we can always access the first parsers to be ran from such a structure.
We require that all the
Alts do not recognise the empty string. These should be covered by the
Maybe in the
|Monad (Gram f)|
|Functor f => Functor (Gram f)|
|Functor f => Applicative (Gram f)|
The left hand side operand is gradually transformed so we get access to its first component
|Functor f => Alternative (Gram f)|
|Functor f => ExtAlternative (Gram f)|
|Functor f => IsParser (Gram f)|
|Show a => Show (Gram f a)|
mkGram splits a simple parser into the possibly empty part and the non-empty part.
The non-empty part recognises a consecutive part of the input.
Here we use the functions
getZeroP which are provided in the uu-parsinglib package,
but they could easily be provided by other packages too.