Text.GRead.Grammar

ChristmasTree-0.1: Changing Haskell's Read Implementation Such That by Mainpulating Abstract Syntax Trees it Reads Expressions Efficiently

Source code

Contents

Index

Text.GRead.Grammar

Contents

Class Gram

Typed Grammar Representations for Data Types

Types
Smart Constructors

Typed Grammar Representations

Types
Smart Constructors
Utils

Description

Representation of Data Type Grammars.

Synopsis

class Gram a where

grammar :: DGrammar a

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

data DGram a env

= DGD (DLNontDefs a env)

| DGG (DGrammar a)

newtype DRef a env = DRef (Ref a env, Int)

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

newtype DProductions a env = DPS {

unDPS :: [DProd a env]

}

data DProd a env where

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

DEnd :: a -> DProd a env

data DSymbol a env where

DNont :: DRef a env -> DSymbol a env

DTerm :: Token -> DSymbol Token env

(.#.) :: 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

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

newtype Productions a env = PS {

unPS :: [Prod a env]

}

data Prod a env where

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

End :: a -> Prod a env

data Symbol a env where

Nont :: Ref a env -> Symbol a env

Term :: Token -> Symbol Token env

data Token

= Keyw String

| Open

| Close

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

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

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

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

Class Gram

class Gram a where

Source

Class of data types with typed grammar representation. It has to be instantiated in order to use the function Text.GRead.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

Source

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

Typed Grammar Representations for Data Types

Types

data DGrammar a

Source

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.