Safe Haskell	None
Language	Haskell2010

Language.Symantic.Grammar.Regular

Contents

Type Reg

Description

Symantics for regular grammars.

Synopsis

newtype Reg (lr :: Side) g a = Reg {
- unReg :: g a
}
reg_of_Terminal :: Terminal g a -> Reg lr g a
type RegL = Reg SideL
type RegR = Reg SideR
class Gram_Alt g where
- empty :: g a
- (<+>) :: g a -> g a -> g a
- choice :: [g a] -> g a
class Gram_Try g where
- try :: g a -> g a
class (Functor g, Gram_Alt g) => Gram_RegR g where
- (.*>) :: Terminal g (a -> b) -> RegR g a -> RegR g b
- manyR :: Terminal g a -> RegR g [a]
- someR :: Terminal g a -> RegR g [a]
class (Functor g, Gram_Alt g) => Gram_RegL g where
- (<*.) :: RegL g (a -> b) -> Terminal g a -> RegL g b
- manyL :: Terminal g a -> RegL g [a]
- someL :: Terminal g a -> RegL g [a]

Type `Reg`

newtype Reg (lr :: Side) g a Source #

Left or right regular grammar.

Constructors

Reg
Fields unReg :: g a

Instances

Gram_Error err g => Gram_Error err (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods catch :: Reg lr g (Either err a) -> Reg lr g a Source #
Gram_State st g => Gram_State st (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods stateBefore :: Reg lr g (st -> (st, a)) -> Reg lr g a Source # stateAfter :: Reg lr g (st -> (st, a)) -> Reg lr g a Source # getBefore :: Reg lr g (st -> a) -> Reg lr g a Source # getAfter :: Reg lr g (st -> a) -> Reg lr g a Source # put :: Reg lr g (st, a) -> Reg lr g a Source #
Gram_Reader st g => Gram_Reader st (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods askBefore :: Reg lr g (st -> a) -> Reg lr g a Source # askAfter :: Reg lr g (st -> a) -> Reg lr g a Source #
ContextFreeOf (Reg lr) Source #
Instance details Defined in Language.Symantic.Grammar.ContextFree Methods cfOf :: Reg lr g a -> CF g a Source #
Functor g => Functor (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular 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) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods ruleEBNF :: EBNF () -> Reg SideL g a -> RuleEBNF a Source # argEBNF :: Text -> Reg SideL g a Source #
Gram_RuleEBNF g => Gram_RuleEBNF (Reg SideR g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods ruleEBNF :: EBNF () -> Reg SideR g a -> RuleEBNF a Source # argEBNF :: Text -> Reg SideR g a Source #
Gram_Rule g => Gram_Rule (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods rule :: Text -> Rule (Reg lr g a) Source # rule1 :: Text -> Rule (Reg lr g a -> Reg lr g b) Source # rule2 :: Text -> Rule (Reg lr g a -> Reg lr g b -> Reg lr g c) Source # rule3 :: Text -> Rule (Reg lr g a -> Reg lr g b -> Reg lr g c -> Reg lr g d) Source # rule4 :: Text -> Rule (Reg lr g a -> Reg lr g b -> Reg lr g c -> Reg lr g d -> Reg lr g e) Source #
Gram_String g => Gram_String (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods string :: String -> Reg lr g String Source # text :: Text -> Reg lr g Text Source # textLazy :: Text -> Reg lr g Text Source #
Gram_Char g => Gram_Char (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods any :: Reg lr g Char Source # but :: Terminal (Reg lr g) Char -> Terminal (Reg lr g) Char -> Terminal (Reg lr g) Char Source # eoi :: Reg lr g () Source # eol :: Reg lr g Char Source # space :: Reg lr g Char Source # char :: Char -> Reg lr g Char Source # unicat :: Unicat -> Reg lr g Char Source # range :: (Char, Char) -> Reg lr g Char Source #
(Functor g, Gram_Alt g, Gram_RegL g) => Gram_RegL (Reg SideL g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (<*.) :: RegL (Reg SideL g) (a -> b) -> Terminal (Reg SideL g) a -> RegL (Reg SideL g) b Source # manyL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a] Source # someL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a] Source #
(Functor g, Gram_Alt g, Gram_RegR g) => Gram_RegR (Reg SideR g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (.*>) :: Terminal (Reg SideR g) (a -> b) -> RegR (Reg SideR g) a -> RegR (Reg SideR g) b Source # manyR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a] Source # someR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a] Source #
Gram_Try g => Gram_Try (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods try :: Reg lr g a -> Reg lr g a Source #
Gram_Alt g => Gram_Alt (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods empty :: Reg lr g a Source # (<+>) :: Reg lr g a -> Reg lr g a -> Reg lr g a Source # choice :: [Reg lr g a] -> Reg lr g a Source #
IsString (g a) => IsString (Reg lr g a) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods fromString :: String -> Reg lr g a #

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

type RegL = Reg SideL Source #

type RegR = Reg SideR Source #

Class `Gram_Alt`

class Gram_Alt g where Source #

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 Source #

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

choice :: [g a] -> g a Source #

Instances

Gram_Alt RuleEBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods empty :: RuleEBNF a Source # (<+>) :: RuleEBNF a -> RuleEBNF a -> RuleEBNF a Source # choice :: [RuleEBNF a] -> RuleEBNF a Source #
Gram_Alt EBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods empty :: EBNF a Source # (<+>) :: EBNF a -> EBNF a -> EBNF a Source # choice :: [EBNF a] -> EBNF a Source #
Gram_Alt p => Gram_Alt (Terminal p) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods empty :: Terminal p a Source # (<+>) :: Terminal p a -> Terminal p a -> Terminal p a Source # choice :: [Terminal p a] -> Terminal p a Source #
Gram_Alt g => Gram_Alt (CF g) Source #
Instance details Defined in Language.Symantic.Grammar.ContextFree Methods empty :: CF g a Source # (<+>) :: CF g a -> CF g a -> CF g a Source # choice :: [CF g a] -> CF g a Source #
Gram_Alt g => Gram_Alt (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods empty :: Reg lr g a Source # (<+>) :: Reg lr g a -> Reg lr g a -> Reg lr g a Source # choice :: [Reg lr g a] -> Reg lr g a Source #

Type `Gram_Try`

class Gram_Try g where Source #

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

Methods

try :: g a -> g a Source #

Instances

Gram_Try RuleEBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods try :: RuleEBNF a -> RuleEBNF a Source #
Gram_Try EBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods try :: EBNF a -> EBNF a Source #
Gram_Try g => Gram_Try (CF g) Source #
Instance details Defined in Language.Symantic.Grammar.ContextFree Methods try :: CF g a -> CF g a Source #
Gram_Try g => Gram_Try (Reg lr g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods try :: Reg lr g a -> Reg lr g a Source #

Class `Gram_RegR`

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

Symantics for right regular grammars.

Minimal complete definition

(.*>)

Methods

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

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

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

Instances

Gram_RegR RuleEBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (.*>) :: Terminal RuleEBNF (a -> b) -> RegR RuleEBNF a -> RegR RuleEBNF b Source # manyR :: Terminal RuleEBNF a -> RegR RuleEBNF [a] Source # someR :: Terminal RuleEBNF a -> RegR RuleEBNF [a] Source #
Gram_RegR EBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (.*>) :: Terminal EBNF (a -> b) -> RegR EBNF a -> RegR EBNF b Source # manyR :: Terminal EBNF a -> RegR EBNF [a] Source # someR :: Terminal EBNF a -> RegR EBNF [a] Source #
Gram_RegR g => Gram_RegR (CF g) Source #
Instance details Defined in Language.Symantic.Grammar.ContextFree Methods (.*>) :: Terminal (CF g) (a -> b) -> RegR (CF g) a -> RegR (CF g) b Source # manyR :: Terminal (CF g) a -> RegR (CF g) [a] Source # someR :: Terminal (CF g) a -> RegR (CF g) [a] Source #
(Functor g, Gram_Alt g, Gram_RegR g) => Gram_RegR (Reg SideR g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (.*>) :: Terminal (Reg SideR g) (a -> b) -> RegR (Reg SideR g) a -> RegR (Reg SideR g) b Source # manyR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a] Source # someR :: Terminal (Reg SideR g) a -> RegR (Reg SideR g) [a] Source #

Class `Gram_RegL`

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

Symantics for left regular grammars.

Minimal complete definition

(<*.)

Methods

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

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

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

Instances

Gram_RegL RuleEBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (<*.) :: RegL RuleEBNF (a -> b) -> Terminal RuleEBNF a -> RegL RuleEBNF b Source # manyL :: Terminal RuleEBNF a -> RegL RuleEBNF [a] Source # someL :: Terminal RuleEBNF a -> RegL RuleEBNF [a] Source #
Gram_RegL EBNF Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (<*.) :: RegL EBNF (a -> b) -> Terminal EBNF a -> RegL EBNF b Source # manyL :: Terminal EBNF a -> RegL EBNF [a] Source # someL :: Terminal EBNF a -> RegL EBNF [a] Source #
Gram_RegL g => Gram_RegL (CF g) Source #
Instance details Defined in Language.Symantic.Grammar.ContextFree Methods (<*.) :: RegL (CF g) (a -> b) -> Terminal (CF g) a -> RegL (CF g) b Source # manyL :: Terminal (CF g) a -> RegL (CF g) [a] Source # someL :: Terminal (CF g) a -> RegL (CF g) [a] Source #
(Functor g, Gram_Alt g, Gram_RegL g) => Gram_RegL (Reg SideL g) Source #
Instance details Defined in Language.Symantic.Grammar.Regular Methods (<*.) :: RegL (Reg SideL g) (a -> b) -> Terminal (Reg SideL g) a -> RegL (Reg SideL g) b Source # manyL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a] Source # someL :: Terminal (Reg SideL g) a -> RegL (Reg SideL g) [a] Source #

Type Reg

Class Gram_Alt

Type Gram_Try

Class Gram_RegR

Class Gram_RegL

Type `Reg`

Class `Gram_Alt`

Type `Gram_Try`

Class `Gram_RegR`

Class `Gram_RegL`