This module contains the additional data types, instance definitions and functions to run parsers in an interleaved way. If all the interlevaed 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
- 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 Gram
Since we want to get access to the individial 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 Alt
s do not recognise the empty string. These should be covered by the Maybe
in the Gram
constructor.
Monad (Gram f) | |
Functor f => Functor (Gram f) | We define instances for the data type |
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 :: P t a -> Gram (P t) aSource
The function 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 function getOneP
and getZeroP
which are provided in the uu-parsinglib package,
but they could easily be provided by other packages too.
Class instances for Gram
Gram
is a Monad
mkParserM :: (Monad f, Applicative f, ExtAlternative f) => Gram f a -> f aSource
The function <<||>
is a special version of <||>
, whch only starts a new instance of its right operand when the left operand cannot proceed.
This is used in the function pmMany, where we want to merge as many instances of its argument, but not more than that.
mkPaserM
converts a Gram
mar beack into a parser, which can subsequenly be run.
mkParserS :: (Monad f, Applicative f, ExtAlternative f) => f b -> Gram f a -> f aSource