Language.Symantic.Grammar.Regular

Symantics for regular grammars.

Type Reg

newtype Reg lr g a

Left or right regular grammar.

Constructors

Reg

Fields

• unReg :: g a

Instances

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

Methods

catch :: Reg lr g (Either err a) -> Reg lr 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

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

ContextFreeOf (Reg lr)

Methods

cfOf :: Reg lr g a -> CF g a

Functor g => Functor (Reg lr g)

Methods

fmap :: (a -> b) -> Reg lr g a -> Reg lr g b

(<$) :: a -> Reg lr g b -> Reg lr g a

Gram_RuleEBNF g => Gram_RuleEBNF (Reg SideL g)

Methods

ruleEBNF :: EBNF () -> Reg SideL g a -> RuleEBNF a

argEBNF :: Text -> Reg SideL g a

Gram_RuleEBNF g => Gram_RuleEBNF (Reg SideR g)

Methods

ruleEBNF :: EBNF () -> Reg SideR g a -> RuleEBNF a

argEBNF :: Text -> Reg SideR g a

Gram_Rule g => Gram_Rule (Reg lr g)

Methods

rule :: Text -> Rule (Reg lr g a)

rule1 :: Text -> Rule (Reg lr g a -> Reg lr g b)

rule2 :: Text -> Rule (Reg lr g a -> Reg lr g b -> Reg lr g c)

rule3 :: Text -> Rule (Reg lr g a -> Reg lr g b -> Reg lr g c -> Reg lr g d)

rule4 :: Text -> Rule (Reg lr g a -> Reg lr g b -> Reg lr g c -> Reg lr g d -> Reg lr g e)

Gram_Terminal g => Gram_Terminal (Reg lr g)

Methods

any :: Reg lr g Char

but :: Terminal (Reg lr g) Char -> Terminal (Reg lr g) Char -> Terminal (Reg lr g) Char

eoi :: Reg lr g ()

char :: Char -> Reg lr g Char

string :: String -> Reg lr g String

unicat :: Unicat -> Reg lr g Char

range :: (Char, Char) -> Reg lr g Char

(Functor g, Gram_Alt g, Gram_RegL g) => Gram_RegL (Reg SideL g)

Methods

(<*.) :: RegL (Reg SideL g) (a -> b) -> Terminal (Reg SideL g) a -> RegL (Reg SideL g) b

manyL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a]

someL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a]

(Functor g, Gram_Alt g, Gram_RegR g) => Gram_RegR (Reg SideR g)

Methods

(.*>) :: Terminal (Reg SideR g) (a -> b) -> RegR (Reg SideR g) a -> RegR (Reg SideR g) b

manyR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a]

someR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a]

Gram_Try g => Gram_Try (Reg lr g)

Methods

try :: Reg lr g a -> Reg lr g a

Gram_Alt g => Gram_Alt (Reg lr g)

Methods

empty :: Reg lr g a

(<+>) :: Reg lr g a -> Reg lr g a -> Reg lr g a

choice :: [Reg lr g a] -> Reg lr g a

IsString (g a) => IsString (Reg lr g a)

Methods

fromString :: String -> Reg lr g a

reg_of_Terminal :: Terminal g a -> Reg lr g a

type RegL = Reg SideL

type RegR = Reg SideR

Class Gram_Alt

class Gram_Alt g where

Like Alternative but without the Applicative super-class, because a regular grammar is not closed under Applicative.

Minimal complete definition

empty, (<+>)

Methods

empty :: g a

(<+>) :: g a -> g a -> g a infixl 3

choice :: [g a] -> g a

Instances

Gram_Alt RuleEBNF

Methods

empty :: RuleEBNF a

(<+>) :: RuleEBNF a -> RuleEBNF a -> RuleEBNF a

choice :: [RuleEBNF a] -> RuleEBNF a

Gram_Alt EBNF

Methods

empty :: EBNF a

(<+>) :: EBNF a -> EBNF a -> EBNF a

choice :: [EBNF a] -> EBNF a

Gram_Alt p => Gram_Alt (Terminal p)

Methods

empty :: Terminal p a

(<+>) :: Terminal p a -> Terminal p a -> Terminal p a

choice :: [Terminal p a] -> Terminal p a

Gram_Alt g => Gram_Alt (CF g)

Methods

empty :: CF g a

(<+>) :: CF g a -> CF g a -> CF g a

choice :: [CF g a] -> CF g a

Gram_Alt g => Gram_Alt (Reg lr g)

Methods

empty :: Reg lr g a

(<+>) :: Reg lr g a -> Reg lr g a -> Reg lr g a

choice :: [Reg lr g a] -> Reg lr g a

Type Gram_Try

class Gram_Try g where

Explicit backtracking.

To get more accurate error messages, it is helpful to backtrack (put try constructors) only when the grammar actually has another alternative that could match, instead of always backtracking all previous alternatives, as in: try a <+> b

Minimal complete definition

try

Methods

try :: g a -> g a

Instances

Gram_Try RuleEBNF

Methods

try :: RuleEBNF a -> RuleEBNF a

Gram_Try EBNF

Methods

try :: EBNF a -> EBNF a

Gram_Try g => Gram_Try (CF g)

Methods

try :: CF g a -> CF g a

Gram_Try g => Gram_Try (Reg lr g)

Methods

try :: Reg lr g a -> Reg lr g a

Class Gram_RegR

class (Functor g, Gram_Alt g) => Gram_RegR g where

Symantics for right regular grammars.

Minimal complete definition

(.*>)

Methods

(.*>) :: Terminal g (a -> b) -> RegR g a -> RegR g b infixl 4

manyR :: Terminal g a -> RegR g [a]

someR :: Terminal g a -> RegR g [a]

Instances

Gram_RegR RuleEBNF

Methods

(.*>) :: Terminal RuleEBNF (a -> b) -> RegR RuleEBNF a -> RegR RuleEBNF b

manyR :: Terminal RuleEBNF a -> RegR RuleEBNF [a]

someR :: Terminal RuleEBNF a -> RegR RuleEBNF [a]

Gram_RegR EBNF

Methods

(.*>) :: Terminal EBNF (a -> b) -> RegR EBNF a -> RegR EBNF b

manyR :: Terminal EBNF a -> RegR EBNF [a]

someR :: Terminal EBNF a -> RegR EBNF [a]

Gram_RegR g => Gram_RegR (CF g)

Methods

(.*>) :: Terminal (CF g) (a -> b) -> RegR (CF g) a -> RegR (CF g) b

manyR :: Terminal (CF g) a -> RegR (CF g) [a]

someR :: Terminal (CF g) a -> RegR (CF g) [a]

(Functor g, Gram_Alt g, Gram_RegR g) => Gram_RegR (Reg SideR g)

Methods

(.*>) :: Terminal (Reg SideR g) (a -> b) -> RegR (Reg SideR g) a -> RegR (Reg SideR g) b

manyR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a]

someR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a]

Class Gram_RegL

class (Functor g, Gram_Alt g) => Gram_RegL g where

Symantics for left regular grammars.

Minimal complete definition

(<*.)

Methods

(<*.) :: RegL g (a -> b) -> Terminal g a -> RegL g b infixl 4

manyL :: Terminal g a -> RegL g [a]

someL :: Terminal g a -> RegL g [a]

Instances

Gram_RegL RuleEBNF

Methods

(<*.) :: RegL RuleEBNF (a -> b) -> Terminal RuleEBNF a -> RegL RuleEBNF b

manyL :: Terminal RuleEBNF a -> RegL RuleEBNF [a]

someL :: Terminal RuleEBNF a -> RegL RuleEBNF [a]

Gram_RegL EBNF

Methods

(<*.) :: RegL EBNF (a -> b) -> Terminal EBNF a -> RegL EBNF b

manyL :: Terminal EBNF a -> RegL EBNF [a]

someL :: Terminal EBNF a -> RegL EBNF [a]

Gram_RegL g => Gram_RegL (CF g)

Methods

(<*.) :: RegL (CF g) (a -> b) -> Terminal (CF g) a -> RegL (CF g) b

manyL :: Terminal (CF g) a -> RegL (CF g) [a]

someL :: Terminal (CF g) a -> RegL (CF g) [a]

(Functor g, Gram_Alt g, Gram_RegL g) => Gram_RegL (Reg SideL g)

Methods

(<*.) :: RegL (Reg SideL g) (a -> b) -> Terminal (Reg SideL g) a -> RegL (Reg SideL g) b

manyL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a]

someL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a]