Language.Symantic.Grammar.Meta

Type Gram_Reader

class Gram_Reader st g where

Minimal complete definition

askBefore, askAfter

Methods

askBefore :: g (st -> a) -> g a

askAfter :: g (st -> a) -> g a

Instances

Gram_Reader st EBNF

Methods

askBefore :: EBNF (st -> a) -> EBNF a

askAfter :: EBNF (st -> a) -> EBNF a

Gram_Reader st RuleEBNF

Methods

askBefore :: RuleEBNF (st -> a) -> RuleEBNF a

askAfter :: RuleEBNF (st -> a) -> RuleEBNF a

Gram_Reader st g => Gram_Reader st (CF g)

Methods

askBefore :: CF g (st -> a) -> CF g a

askAfter :: CF g (st -> a) -> CF g a

Gram_Reader st g => Gram_Reader st (Reg lr g)

Methods

askBefore :: Reg lr g (st -> a) -> Reg lr g a

askAfter :: Reg lr g (st -> a) -> Reg lr g a

Type Gram_State

class Gram_State st g where

Minimal complete definition

stateBefore, stateAfter

Methods

stateBefore :: g (st -> (st, a)) -> g a

stateAfter :: g (st -> (st, a)) -> g a

getBefore :: g (st -> a) -> g a

getAfter :: g (st -> a) -> g a

put :: g (st, a) -> g a

getBefore :: Functor g => g (st -> a) -> g a

getAfter :: Functor g => g (st -> a) -> g a

put :: Functor g => g (st, a) -> g a

Instances

Gram_State st EBNF

Methods

stateBefore :: EBNF (st -> (st, a)) -> EBNF a

stateAfter :: EBNF (st -> (st, a)) -> EBNF a

getBefore :: EBNF (st -> a) -> EBNF a

getAfter :: EBNF (st -> a) -> EBNF a

put :: EBNF (st, a) -> EBNF a

Gram_State st RuleEBNF

Methods

stateBefore :: RuleEBNF (st -> (st, a)) -> RuleEBNF a

stateAfter :: RuleEBNF (st -> (st, a)) -> RuleEBNF a

getBefore :: RuleEBNF (st -> a) -> RuleEBNF a

getAfter :: RuleEBNF (st -> a) -> RuleEBNF a

put :: RuleEBNF (st, a) -> RuleEBNF a

Gram_State st g => Gram_State st (CF g)

Methods

stateBefore :: CF g (st -> (st, a)) -> CF g a

stateAfter :: CF g (st -> (st, a)) -> CF g a

getBefore :: CF g (st -> a) -> CF g a

getAfter :: CF g (st -> a) -> CF g a

put :: CF g (st, a) -> CF g a

Gram_State st g => Gram_State st (Reg lr g)

Methods

stateBefore :: Reg lr g (st -> (st, a)) -> Reg lr g a

stateAfter :: Reg lr g (st -> (st, a)) -> Reg lr g a

getBefore :: Reg lr g (st -> a) -> Reg lr g a

getAfter :: Reg lr g (st -> a) -> Reg lr g a

put :: Reg lr g (st, a) -> Reg lr g a

Class Gram_Error

class Gram_Error err g where

Symantics for handling errors at the semantic level (not the syntaxic one).

Minimal complete definition

catch

Methods

catch :: g (Either err a) -> g a

Instances

Gram_Error err EBNF

Methods

catch :: EBNF (Either err a) -> EBNF a

Gram_Error err RuleEBNF

Methods

catch :: RuleEBNF (Either err a) -> RuleEBNF a

Gram_Error err g => Gram_Error err (CF g)

Methods

catch :: CF g (Either err a) -> CF g a

Gram_Error err g => Gram_Error err (Reg lr g)

Methods

catch :: Reg lr g (Either err a) -> Reg lr g a

Class Gram_Source

class (Gram_Reader (Source_Input src) g, SourceInj (Span (Source_Input src)) src) => Gram_Source src g where

Methods

source :: Functor g => g (src -> a) -> g a

Instances

(Gram_Reader (Source_Input src) g, SourceInj (Span (Source_Input src)) src) => Gram_Source src g

Methods

source :: Functor g => g (src -> a) -> g a