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 `Gram`

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 `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 functions `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

mkParserS :: (Monad f, Applicative f, ExtAlternative f) => f b -> Gram f a -> f aSource