Ah, I found the attachment on your other email.
I would recommend using the Fix and Ann types, instead of the AnnFix type.
I modified your code a bit (and fixed the Show instances etc...) and put it
here:
http://hpaste.org/fastcgi/hpaste.fcgi/view?id=27823#a27823
Let me know if you have questions about it.
- Job
http://hpaste.org/fastcgi/hpaste.fcgi/view?id=27823#a27823
2010/7/19 Job Vranish
I didn't get any attachments from you, but haskell-cafe might filter them out (I'm not sure).
But, the usual derived instances for Show should work fine for your expression and annotation types. For the Fix type you can use:
instance (Show (f (Fix f))) => Show (Fix f) where show (Fix a) = show "Fix " ++ show a
hmmm, but you'll probably need:
{-# LANGUAGE FlexibleContexts, UndecidableInstances #-}
- Job
2010/7/19 José Romildo Malaquias
On Mon, Jul 19, 2010 at 01:51:57PM -0400, Job Vranish wrote:
Martijn van Steenbergen has a good blog post that describes the method I generally use:
http://martijn.van.steenbergen.nl/journal/2010/06/24/generically-adding-posi...
In his example he annotates the expression tree with position
information,
but you can use the same method to add type annotations, or whatever you want.
After a quick read at Martijn blog article I've written the attached test program, which works.
But I am not succeeding in deriving Show for the data types. Any help?
Romildo
2010/7/19 José Romildo Malaquias
Hello.
In his book "Modern Compilder Implementation in ML", Appel presents a compiler project for the Tiger programming language where type checking and intermediate code generation are intrinsically coupled.
There is a function
transExp :: Absyn.Exp -> (Tree.Exp,Types.Type)
that do semantic analysis, translating an expression to the Tree intermediate representation language and also do type checking, calculating the type of the expression.
Maybe the compiler can be made more didatic if these phases are separate phases of compilation.
The type checker would annotate the abstract syntax tree (ast) with type annotations, that could be used later by the translater to intermediate representation.
In an imperative language probably each relevant ast node would have a field for the type annotation, and the type checker would assign the type of the node to this field after computing it.
I am writing here to ask suggestions on how to annotate an ast with types (or any other information that would be relevant in a compiler phase) in Haskell.
As an example, consider the simplified ast types:
data Exp = IntExp Integer | VarExp Symbol | AssignExp Symbol Exp | IfExp Exp Exp (Maybe Exp) | CallExp Symbol [Exp] | LetExp [Dec] Exp
data Dec = TypeDec Symbol Ty | FunctionDec Symbol [(Symbol,Symbol)] (Mybe Symbol) Exp | VarDec Symbol (Maybe Symbol) Exp
Expressions can have type annotations, but declarations can not.
Comments?