Text.Grampa.ContextFree.SortedMemoizing.Transformer.LeftRecursive

A context-free parser that can handle ambiguous left-recursive grammars and carry a monadic computation with each parsing result.

Documentation

type ParserT m = Fixed (ParserT m)

Parser transformer for left-recursive grammars on top of ParserT.

data SeparatedParser p (g :: (Type -> Type) -> Type) s a

A type of parsers analyzed for their left-recursion class

Constructors

FrontParser (p g s a)

a parser that no left-recursive nonterminal depends on

CycleParser

a left-recursive parser that may add to the set of parse results every time it's run

Fields

• cycleParser :: p g s a
• backParser :: p g s a
• appendResultsArrow :: ResultAppend p g s a
• dependencies :: Dependencies g

BackParser

a parser that doesn't start with any nonTerminal so it can run first

Fields

• backParser :: p g s a

class AmbiguityDecidable a

Minimal complete definition

ambiguityWitness

Instances

AmbiguityDecidable a

Defined in Text.Grampa.Internal

Methods

ambiguityWitness :: Maybe (AmbiguityWitness a)

AmbiguityDecidable (Ambiguous a)

Defined in Text.Grampa.Internal

Methods

ambiguityWitness :: Maybe (AmbiguityWitness (Ambiguous a))

lift :: (Applicative m, Ord s) => m a -> ParserT m g s a

Lift a parse-free computation into the parser.

liftPositive :: p g s a -> Fixed p g s a

Lifts a primitive positive parser (i.e., one that always consumes some input) into a left-recursive one

tbind :: (Monad m, AmbiguityDecidable b) => ParserT m g s a -> (a -> m b) -> ParserT m g s b

Transform the computation carried by the parser using the monadic bind (>>=).

tmap :: AmbiguityDecidable b => (m a -> m b) -> ParserT m g s a -> ParserT m g s b

Transform the computation carried by the parser.

autochain :: forall p g s f rl (cb :: Type -> Type). (cb ~ Const (g (Const Bool)), f ~ GrammarFunctor (p g s), f ~ rl s, LeftRecParsing p g s rl, DeterministicParsing (p g s), Apply g, Traversable g, Distributive g, Logistic g) => g (Fixed p g s) -> g (Fixed p g s)

Automatically apply chainRecursive and chainLongestRecursive to left-recursive grammar productions where possible.

parseSeparated :: forall p g rl s. (Apply g, Foldable g, Eq s, FactorialMonoid s, LeftReductive s, TailsParsing (p g s), GrammarConstraint (p g s) g, GrammarFunctor (p g s) ~ rl s, FallibleResults rl, s ~ ParserInput (p g s)) => g (SeparatedParser p g s) -> s -> [(s, g (GrammarFunctor (p g s)))]

Parse the given input using a context-free grammar separated into left-recursive and other productions.

separated :: forall p g s. (Alternative (p g s), Apply g, Distributive g, Traversable g, AmbiguousAlternative (GrammarFunctor (p g s))) => g (Fixed p g s) -> g (SeparatedParser p g s)

Analyze the grammar's production interdependencies and produce a SeparatedParser from each production's parser.