September 2003 - template-haskell

More useful ones
by Sean Seefried 27 Sep '03

27 Sep '03

Often when analysing expressions I want to get all the arguments for a function. The following function decomposes such an application chain. -- Should only be used on expression of form (App e1 e2) getAppChain :: Exp -> (Exp, [Exp]) getAppChain (AppE e1 e2) = let (f, args) = getAppChain e1 in (f, args ++ [e2]) getAppChain e = (e, []) -- The dual of getAppChain mkAppChain :: (Exp, [Exp]) -> Exp mkAppChain (f, args) = foldl1 AppE (f:args) putExpQLn :: ExpQ -> IO () putExpQLn expQ= do exp <- runQ expQ putStrLn (show exp) -- Two very useful functions. -- And these are just good for printing out code. putQ :: Show a => Q a -> IO () putQ xQ = do x <- runQ xQ putStr (show x) putQLn :: Show a => Q a -> IO () putQLn xQ = do putQ xQ putStrLn ""

1 0

Useful TH library functions
by Alastair Reid 26 Sep '03

26 Sep '03

Here's some functions I found myself needing when I wrote Template Greencard which I think would be useful additions to the TH libraries. The names could probably be a bit better and, in some cases, putting a function in the Q monad (i.e., lift the args and result) might be helpful. -- Functions for building types --| mkIOTy alpha = [| IO alpha |] mkIOTy :: Typ -> Typ mkIOTy ty = ConTyp (ConNameTag "GHC.IOBase:IO") `AppTyp` ty --| mkArrows [t1,...tm] rty = [| t1 -> ... -> tm -> rty |] mkArrows :: [Typ] -> Typ -> Typ mkArrows as r = foldr (\ a as -> tapply (ConTyp ArrowTag) [a,as]) r as --| mkTupleTy [t1, ... tm] = [| (t1, ... tm) |] mkTupleTy :: [Typ] -> Typ mkTupleTy [] = htype_Void mkTupleTy [ty] = ty mkTupleTy tys = tapply (ConTyp (TupleTag (length tys))) tys --| tapply tc [t1,...tm] = [| tc t1 ... tm |] tapply :: Typ -> [Typ] -> Typ tapply f [] = f tapply f (a:as) = tapply (AppTyp f a) as -- Functions for taking types apart --| unarrow [| t1 -> ... tm -> rty |] = ([t1, ... tm], rty) unarrow :: Typ -> ([Typ],Typ) unarrow (AppTyp (AppTyp (ConTyp ArrowTag) ty1) ty2) = let (as,r) = unarrow ty2 in (ty1:as,r) unarrow ty = ([],ty) --| unIO [| IO ty |] = (True, ty) unIO :: Typ -> (Bool,Typ) unIO (AppTyp (ConTyp (ConNameTag "GHC.IOBase:IO")) ty) = (True, ty) unIO ty = (False, ty) --| untuple [| (ty1,...tm) |] = [ty1,..tm] untuple :: Typ -> [Typ] untuple ty = case split ty of (ConTyp (TupleTag n), tys) -> tys (ConTyp (ConNameTag "GHC.Base:()"),[]) -> [] _ -> [ty] -- Functions for building expressions and patterns --| simpleLet v e body = [| let v = e in body |] simpleLet :: Var -> Q Exp -> Q Exp -> Q Exp simpleLet v e body = letE [val (VarPat v) (normal e) []] body --| mkPTuple [p1,...pm] = [| (p1,...pm() |] mkPTuple :: [Pat] -> Pat mkPTuple [p] = p mkPTuple ps = TupPat ps -- Reifications of common types -- (The important thing here is that they are not in the Q monad -- so I can refer to them in guards.) htype_Ptr :: HType htype_Ptr = ConTyp (ConNameTag "GHC.Ptr:Ptr") htype_FunPtr :: HType htype_FunPtr = ConTyp (ConNameTag "GHC.Ptr:FunPtr") htype_StablePtr :: HType htype_StablePtr = ConTyp (ConNameTag "GHC.Stable:StablePtr") htype_Void :: HType htype_Void = ConTyp (ConNameTag "GHC.Base:()")

1 0

RE: [Template-haskell] reifyLocn
by Simon Peyton-Jones 22 Sep '03

22 Sep '03

Yes, it's in the works, but don't hold your breath. The next iteration of TH won't be out for at least a couple of months, I'm afraid. I hope this isn't a show-stopper for you. Simon | -----Original Message----- | From: template-haskell-bounces(a)haskell.org [mailto:template-haskell-bounces@haskell.org] On | Behalf Of Brett Letner | Sent: 19 September 2003 23:14 | To: template-haskell(a)haskell.org | Subject: [Template-haskell] reifyLocn | | Is reifyLocn in the works? | | I'd like to use it to splice into my error messages (similar to what | assert gives you). | | Thanks - | | -- | Brett Letner | Galois Connections, Inc. | http://www.galois.com | mailto:bletner@galois.com | phone:(503)626-6616 ext.110 | | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

1 0

reifyLocn
by Brett Letner 19 Sep '03

19 Sep '03

Is reifyLocn in the works? I'd like to use it to splice into my error messages (similar to what assert gives you). Thanks - -- Brett Letner Galois Connections, Inc. http://www.galois.com mailto:bletner@galois.com phone:(503)626-6616 ext.110

1 0

RE: [Template-haskell] RE: Question regarding template Haskell
by Simon Peyton-Jones 18 Sep '03

18 Sep '03

| typeOf :: a -> TypeRep | | rType :: a -> Typ (or :: a -> Type in the new THSyntax definitions). | | The two are conceptually the same, but they return you different data | types... | Come to think of it, now that we have a concrete syntax, perhaps it'd | be worth merging the definitions of THSyntax's Type and Data.Dynamic's | TypeRep? They're conceptually the same thing, but with different data | representations ... That would make perfect sense. The only tricky bit is that TypeRep is hash-cons'd so that we can guaranteed to compare TypeReps in constant time. It would probably do no harm to hash-cons Typ's too, I guess. With Ralf Laemmel I've been working on a sort of extension to the Typeable class that gives more info for algebraic data types. The module signature is below. We're working on a paper. Let's muse on this. Simon module Data.Generics.Basics ( -- * The Data class for processing constructor applications Data( gfoldl, -- :: ... -> a -> c a toConstr, -- :: a -> Constr fromConstr, -- :: Constr -> a dataTypeOf -- :: a -> DataType ), -- * Constructor representations Constr, -- abstract, instance of: Eq, Show ConIndex, -- alias for Int, start at 1 Fixity(..), -- instance of: Eq, Show DataType, -- abstract, instance of: Show -- * Constructing constructor representations mkConstr, -- :: ConIndex -> String -> Fixity -> Constr mkDataType, -- :: [Constr] -> DataType -- * Observing constructor representations conString, -- :: Constr -> String conFixity, -- :: Constr -> Fixity conIndex, -- :: Constr -> ConIndex stringCon, -- :: DataType -> String -> Maybe Constr indexCon, -- :: DataType -> ConIndex -> Constr maxConIndex, -- :: DataType -> ConIndex dataTypeCons, -- :: DataType -> [Constr]

1 0

RE: [Template-haskell] RE: Question regarding template Haskell
by Simon Peyton-Jones 18 Sep '03

18 Sep '03

I missed that message. How does rType differ from typeOf, defined in Data.Typeable? simon | -----Original Message----- | From: ozone(a)algorithm.com.au [mailto:ozone@algorithm.com.au] | Sent: 17 September 2003 11:04 | To: Simon Peyton-Jones | Cc: template-haskell(a)haskell.org; diyu60607(a)yahoo.com | Subject: Re: [Template-haskell] RE: Question regarding template Haskell | | On 17/09/2003, at 7:45 PM, Simon Peyton-Jones wrote: | | > | Hi, I have a question regarding template Haskell: from | > | the documentation, I have the impression that it is | > | impossible to reify the type of the variable passed to | > | the template function, is this true? Or, in other | > | words, can I write a function like: | > | | > | getTupleCount :: a -> ExpQ | > | | > | getTupleCount x= | > | do | > | t <- (reifyType x) | > | --work on t | > | ... | | If your 'x' variable is monomorphic, you can use the rType function | that Sean and I came up with, detailed here: | | | http://www.haskell.org/pipermail/template-haskell/2003-July/000128.html | | That currently handles only 2-tuples, but it shouldn't be too hard to | extend it to work on any-size tuples. Let me know if you're having | problems. | | | -- | % Andre Pang : trust.in.love.to.save

2 1

RE: Question regarding template Haskell
by Simon Peyton-Jones 17 Sep '03

17 Sep '03

[I'm redirecting this to the Template Haskell mailing list, where it more properly belongs.] Interesting question. Tim and I are working on revising the 'reifyType' story, but even in our revised version, your program will be rejected with a staging error. reifyType gives a way to consult the compiler's type environment, at the moment when the ExpQ is run. But at that moment 'x' isn't in scope any more. [Tim: this might make a good example for the design notes you're working on.] You might instead wonder if you can write getup :: ExpQ -> ExpQ which asks what the type of the expression passed to it is. This one has come up before, and I don't think we have a good answer yet. Trouble is (a) although quoted code is type-checked, there's not enough info to do a full type-check (b) it's not obvious how to record whatever the type checker does discover. Still an open question, then. Simon | -----Original Message----- | From: libraries-bounces(a)haskell.org [mailto:libraries-bounces@haskell.org] On Behalf Of Yu Di | Sent: 12 September 2003 03:33 | To: libraries(a)haskell.org | Subject: Question regarding template Haskell | | Hi, I have a question regarding template Haskell: from | the documentation, I have the impression that it is | impossible to reify the type of the variable passed to | the template function, is this true? Or, in other | words, can I write a function like: | | getTupleCount :: a -> ExpQ | | getTupleCount x= | do | t <- (reifyType x) | --work on t | ... | | which returns an expression that is an integer for any | tuple input, but reduces to error for any input that | is not a tuple? | | Thanks! | | Di, Yu | 9.11 | | __________________________________ | Do you Yahoo!? | Yahoo! SiteBuilder - Free, easy-to-use web site design software | http://sitebuilder.yahoo.com | _______________________________________________ | Libraries mailing list | Libraries(a)haskell.org | http://www.haskell.org/mailman/listinfo/libraries

2 1

program transformation
by Ganesh Sittampalam 12 Sep '03

12 Sep '03

I'm currently investigating the possibility of redoing MAG in Template Haskell. MAG is essentially (at least for the purposes of this email) a system that takes a source program and a bunch of rewrite rules, and applies the rewrite rules to the program. I'd like to be able to do this in TH with as little syntactic noise for the user as possible. The general idea (at the moment) would be to put the original program within [d| |] brackets, the set of rewrite rules within [| |] brackets, run a function on the two and splice in the result. It's not the main purpose of this email, but I should mention that being able to splice in code in the same module as it is defined would be very useful for this application, since otherwise any module that makes use of this will need to be split into two. There was a previous discussion about TH and Hydra at http://www.haskell.org/pipermail/template-haskell/2003-January/000008.html, which ended up with the idea of using [d| |] brackets for code that was to be transformed. The extra twist for me is that I have this set of rewrite rules that I also want to use quasi-quotes for. A simplified example of a rewrite rule that uses the associativity of (++) is as follows: \xs ys zs -> (xs ++ ys) ++ zs ==> xs ++ (ys ++ zs) ==> is an operator of type a -> a -> RewriteRule, so GHC will check for me that the rewrite rule is type correct. The lambda binding for xs, ys and zs specifies that the rewrite rule works for any value of them, and also keeps the compiler happy that I haven't used undefined variables. Of course, I'm never intending to actually run this code, I'll just use the result of quasi-quoting it to apply transformations. Anyway, this all works fine. Now, let's suppose that my original program defines the function reverse (hiding the Prelude reverse function), and I want to write a rewrite rule mentioning reverse too. I end up with something like this: reversecode = [d| reverse [] = [] reverse (x:xs) = reverse xs ++ [x] |] rules = [| [ reverse [] ==> [] ] |] The second definition won't compile, since reverse isn't in scope anywhere. I'm trying to work out a good solution to this problem; so far I've come up with the following ideas: (a) Merge the rewrite rules and the declarations. E.g: [| let reverse [] = [] reverse (x:xs) = reverse xs ++ [x] in [ reverse [] ==> [] ... ] |] Pros: - this should actually work for me right now (not actually tested - though) Cons: - it violates the nice separation between code and transformation, - it doesn't read nicely for the user; in particular it'll be unpleasant for them to take some existing code and decide to use MAG on it (b) Use a lambda-abstraction or let-binding to make "reverse" appear to be defined. Pros: - again this ought to work right now Cons: - unless I textually duplicate code, it won't be properly type-checked - the renamer will rename "reverse" and I'll have to make some nasty assumptions about how that works to get back to the original form (c) Turn the rewrite rules into a separate [d| |] block, and splice in $(reversecode) at the beginning Pros: - Not nearly as inelegant/nasty as (a) or (b) Cons: - I still have to search the declaration list for the rewrite rules - This will fall foul of the (second) bug I reported yesterday (d) Say something like let $(reversecode) in reverse [] ==> [] Pros: - Seems even less nasty than the above options Cons: - disallowed by design in TH, for good reasons; it destroys the ability to see where things are bound statically I'd appreciate any comments or alternative suggestions. Ideally I think I'm looking for some nice concise way to say that the rewrite rules quasi-quotes should be parsed and type-checked in the context of the declarations in original code quasi-quotes. Cheers, Ganesh

1 0

RE: [Template-haskell] another TH panic
by Simon Peyton-Jones 12 Sep '03

12 Sep '03

| I'm emailing these panics to this list rather than glasgow-haskell-bugs | since they're obviously TH-related and I suspect are mostly to do with | errors on my part or unimplemented features. Hope that's OK with people. Yes, that's the right thing to do. I'm working hard on some GHC re-engineering, with a view to making (new bits of) TH easier to implement. In parallel, Tim is writing up notes about our proposed changes to TH. We'll put them out for comment shortly. Meanwhile, I'm hoping that no one is really stuck with any TH bugs. If so, please make it clear -- otherwise I'm just collecting them. Realistically, it'll be another couple of months at least before the new TH iteration will arrive. Simon

1 0

another TH panic
by Ganesh Sittampalam 11 Sep '03

11 Sep '03

I'm emailing these panics to this list rather than glasgow-haskell-bugs since they're obviously TH-related and I suspect are mostly to do with errors on my part or unimplemented features. Hope that's OK with people. Again the following panic is from CVS 20030903. Cheers, Ganesh ghc-6.1: panic! (the `impossible' happened, GHC version 6.1): addImpDecls Code is: module THTest where import Language.Haskell.THSyntax code1 = [d| foo = 1 |] code2 = [d| $(code1) bar = foo |]

1 0