Text.GRead.Grammar

Representation of Data Type Grammars.

Class Gram

class Gram a where

Class of data types with typed grammar representation. It has to be instantiated in order to use the function gread.

Instances can be derived automatically using the functions defined in the module Text.GRead.Derive.

For example, given the declarations

 infixl 5 :<:
 infixr 6 :>:, :*:
 
 data T1  =  T1 :<: T1
          |  T1 :>: T1
          |  C1
 
 data T2 a  =  a :*: T2 a
            |  C2

the instances of Gram can be

 _0 = Zero
 _1 = Suc _0
 
 instance Gram T1 where
  grammar = DGrammar   _0 envT1
 
 envT1 :: Env DGram ((),T1) ((),T1) 
 envT1 =  consD (nonts _0) Empty 
      where
       nonts _T1 = DLNontDefs
        [  (  DRef (_T1, 5) 
           ,  DPS  [  dNont (_T1, 5) .#. dTerm ":<:" .#.
                      dNont (_T1, 6) .#. dEnd infixL ]
           )
        ,  (  DRef (_T1, 6) 
           ,  DPS  [  dNont (_T1, 7) .#. dTerm ":>:" .#.
                      dNont (_T1, 6) .#. dEnd infixR ] 
           ) 
        ,  (  DRef (_T1,10) 
           ,  DPS  [  dTerm "C1"   .#. dEnd (const C1)
                   ,  dTerm "(" .#. dNont (_T1,0) .#. 
                      dTerm ")" .#. dEnd parenT ] 
           )
        ]
       infixL e1 _ e2   = e2 :<: e1
       infixR e1 _ e2   = e2 :>: e1 
 
 instance Gram a => Gram (T2 a) where
  grammar = DGrammar   _0  envT2 
 
 envT2 :: (Gram a) => Env DGram  (((),a),T2 a)
                                 (((),a),T2 a)
 envT2 =  consD (nonts  _0 _1) $ 
          consG grammar Empty
      where
       nonts _T2 _A = DLNontDefs
        [  (  DRef (_T2, 6)
           ,  DPS  [  dNont (_A,   7)  .#. dTerm ":*:" .#. 
                      dNont (_T2,  7)  .#. dEnd infixT ] 
           )
        ,  (  DRef (_T2,10) 
           ,  DPS  [  dTerm "C2"   .#. dEnd (const C2)
                   ,  dTerm "("    .#. dNont (_T2,0) .#. 
                      dTerm ")"    .#. dEnd parenT ] 
           )
        ]
       infixP   e1 _ e2  = e2 :+: e1
       infixT   e1 _ e2  = e2 :*: e1 

In case of mutually recursive datatypes, their definitions have to be tupled together into a single environment.

Methods

grammar :: DGrammar a

The function grammar returns the grammar representation of the data type.

Typed Grammar Representations for Data Types

Types

data DGrammar a

Data type describing grammatical structures of data types, including information about precedences. The type DGrammar a describes the grammar of the data type a.

Constructors

forall env . DGrammar (Ref a env) (Env DGram env env)

A grammar consists of an environment (Env) with the defined non-terminals and a reference (Ref) to the main non-terminal in the environment.

data DGram a env

Constructors

DGD (DLNontDefs a env)

DGG (DGrammar a)

newtype DRef a env

Constructors

DRef (Ref a env, Int)

newtype DLNontDefs a env

Constructors

DLNontDefs [(DRef a env, DProductions a env)]

newtype DProductions a env

Constructors

DPS

Fields

unDPS :: [DProd a env]

data DProd a env where

Constructors

DSeq :: DSymbol b env -> DProd (b -> a) env -> DProd a env

DEnd :: a -> DProd a env

data DSymbol a env where

Constructors

DNont :: DRef a env -> DSymbol a env

DTerm :: Token -> DSymbol Token env

Smart Constructors

(.#.) :: DSymbol b env -> DProd (b -> a) env -> DProd a env

consG :: DGrammar a -> Env DGram use def' -> Env DGram use (def', a)

consD :: DLNontDefs a env -> Env DGram env def' -> Env DGram env (def', a)

dNont :: (Ref a env, Int) -> DSymbol a env

dTerm :: [Char] -> DSymbol Token env

dEnd :: a -> DProd a env

parenT :: t -> t1 -> t2 -> t1

Typed Grammar Representations

Types

data Grammar a

Constructors

forall env . Grammar (Ref a env) (Env Productions env env)

newtype Productions a env

Constructors

PS

Fields

unPS :: [Prod a env]

data Prod a env where

Constructors

Seq :: Symbol b env -> Prod (b -> a) env -> Prod a env

End :: a -> Prod a env

data Symbol a env where

Constructors

Nont :: Ref a env -> Symbol a env

Term :: Token -> Symbol Token env

data Token

Constructors

Keyw String

Open

Close

Instances

Eq Token

Ord Token

Show Token

Symbol Token

Smart Constructors

ext :: Env Productions env def' -> [Prod a env] -> Env Productions env (def', a)

(.*.) :: Symbol b env -> Prod (b -> a) env -> Prod a env

Utils

matchSym :: Symbol a env -> Symbol b env -> Maybe (Equal a b)

append :: (a -> b -> c) -> Prod a env -> Symbol b env -> Prod c env