Safe Haskell | None |
---|
Generic representation of typed syntax trees
For details, see: A Generic Abstract Syntax Model for Embedded Languages (ICFP 2012, http://www.cse.chalmers.se/~emax/documents/axelsson2012generic.pdf).
- data AST dom sig where
- type ASTF dom a = AST dom (Full a)
- newtype Full a = Full {
- result :: a
- newtype a :-> sig = Partial (a -> sig)
- size :: AST dom sig -> Int
- class ApplySym sig f dom | sig dom -> f, f -> sig dom where
- type family DenResult sig
- data (dom1 :+: dom2) a where
- class Project sub sup where
- class Project sub sup => sub :<: sup where
- inj :: sub a -> sup a
- appSym :: (ApplySym sig f dom, sym :<: AST dom) => sym sig -> f
Syntax trees
Generic abstract syntax tree, parameterized by a symbol domain
(
represents a partially applied (or unapplied)
symbol, missing at least one argument, while AST
dom (a :->
b))(
represents a fully applied symbol, i.e. a complete syntax tree.
AST
dom (Full
a))
(Project sub (AST sup), :<: sub sup) => sub :<: (AST sup) | |
Project sub sup => Project sub (AST sup) | |
(Project sub (AST sup), Sat (AST sup) sig, InjectC sub sup sig) => InjectC sub (AST sup) sig | |
Equality dom => Equality (AST dom) | |
(Render (AST dom), ToTree dom) => ToTree (AST dom) | |
Render dom => Render (AST dom) | |
Eval dom => Eval (AST dom) | |
Constrained dom => Constrained (AST dom) | |
ApplySym (Full a) (ASTF dom a) dom | |
Equality dom => Eq (AST dom a) | |
Render dom => Show (AST dom a) | |
(Sat dom (Internal (ASTF dom a)), Constrained dom, Sat dom a) => Syntactic (ASTF dom a) dom | |
(Syntactic a dom, ~ * ia (Internal a), SyntacticN b ib) => SyntacticN (a -> b) (AST dom (Full ia) -> ib) | |
ApplySym sig f dom => ApplySym (:-> a sig) (ASTF dom a -> f) dom |
Signature of a fully applied symbol
Typeable1 Full | |
Eq a => Eq (Full a) | |
Show a => Show (Full a) | |
ApplySym (Full a) (ASTF dom a) dom | |
(Sat dom (Internal (ASTF dom a)), Constrained dom, Sat dom a) => Syntactic (ASTF dom a) dom | |
(Syntactic a dom, ~ * ia (Internal a), SyntacticN b ib) => SyntacticN (a -> b) (AST dom (Full ia) -> ib) | |
ApplySym sig f dom => ApplySym (:-> a sig) (ASTF dom a -> f) dom |
Signature of a partially applied (or unapplied) symbol
Partial (a -> sig) |
class ApplySym sig f dom | sig dom -> f, f -> sig dom whereSource
Class for the type-level recursion needed by appSym
Symbol domains
data (dom1 :+: dom2) a whereSource
Direct sum of two symbol domains
(Project expr1 (:+: expr2 expr3), :<: expr1 expr3) => expr1 :<: (:+: expr2 expr3) | |
Project expr1 (:+: expr1 expr2) => expr1 :<: (:+: expr1 expr2) | |
Project expr1 expr3 => Project expr1 (:+: expr2 expr3) | |
Project expr1 (:+: expr1 expr2) | |
(Project expr1 (:+: expr2 expr3), Sat (:+: expr2 expr3) sig, InjectC expr1 expr3 sig) => InjectC expr1 (:+: expr2 expr3) sig | |
(Project expr1 (:+: expr1 expr2), Sat (:+: expr1 expr2) sig) => InjectC expr1 (:+: expr1 expr2) sig | |
(Equality expr1, Equality expr2) => Equality (:+: expr1 expr2) | |
(Render (:+: expr1 expr2), ToTree expr1, ToTree expr2) => ToTree (:+: expr1 expr2) | |
(Render expr1, Render expr2) => Render (:+: expr1 expr2) | |
(Eval expr1, Eval expr2) => Eval (:+: expr1 expr2) | |
Constrained (:+: sub1 sub2) | |
(EvalBind sub1, EvalBind sub2) => EvalBind (:+: sub1 sub2) | |
(Optimize sub1, Optimize sub2) => Optimize (:+: sub1 sub2) | |
(Constrained (HODomain dom p), Sat (HODomain dom p) (Internal (a -> b)), Syntactic a (HODomain dom p), Syntactic b (HODomain dom p), p (Internal a), p (Internal a -> Internal b)) => Syntactic (a -> b) (HODomain dom p) | |
(AlphaEq subA1 subB1 dom env, AlphaEq subA2 subB2 dom env) => AlphaEq (:+: subA1 subA2) (:+: subB1 subB2) dom env | |
(Equality expr1, Equality expr2) => Eq (:+: expr1 expr2 a) | |
(Render expr1, Render expr2) => Show (:+: expr1 expr2 a) | |
(Constrained (HODomain dom Typeable), Sat (HODomain dom Typeable) (Internal (Mon dom m a)), Syntactic a (HODomain dom Typeable), InjectC (MONAD m) dom (m (Internal a)), Monad m, Typeable1 m, Typeable (Internal a)) => Syntactic (Mon dom m a) (HODomain dom Typeable) |