October 2003 - template-haskell

RE: [Template-haskell] program transformation
by Simon Peyton-Jones 07 Nov '03

07 Nov '03

I'm returning to the question of reification in Template Haskell. Would it help here if one could say reify :: Var -> Q Decl and get the declaration for 'reverse'? (Var is as in the "notes" Postscript file I posted yesterday.) I can arrange that iff reverse is defined in the same module. Thus reverse = ... foo = $( do { rev_dec <- reify 'reverse; ... }) (The 'reverse is like a quote [|reverse|], but gets a Var not an Exp.) This is much harder if reverse is imported, because we simply don't have access to reverse's source code any more. (But type constructors and classes are fine. -- excluding the default-method bindings of the class.) Would this help? Simon | -----Original Message----- | From: template-haskell-bounces(a)haskell.org [mailto:template-haskell-bounces@haskell.org] On | Behalf Of Ganesh Sittampalam | Sent: 12 September 2003 17:10 | To: template-haskell(a)haskell.org | Subject: [Template-haskell] program transformation | | 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.ht ml, | 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 | | | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

2 1

RE: [Template-haskell] RE: Template Haskell...
by Simon Peyton-Jones 03 Nov '03

03 Nov '03

Not so. We split at top-level declaration splices. What about this, though? NO splitting involved. f :: Int -> Q Exp f n = [| n+2 |] g x = x + $(f 3) Furthermore, we don't want to *always* compile-to-byte-code all the preceding code in a module. usually none of it'll b needed S | -----Original Message----- | From: template-haskell-bounces(a)haskell.org [mailto:template-haskell-bounces@haskell.org] On | Behalf Of Alastair Reid | Sent: 31 October 2003 17:35 | To: Simon Peyton-Jones; MR K P SCHUPKE; template-haskell(a)haskell.org | Subject: Re: [Template-haskell] RE: Template Haskell... | | On Friday 31 October 2003 5:24 pm, Simon Peyton-Jones wrote: | > Trouble is, that's thoroughly awkward one to implement, because it means | > compiling the transitive closure of all the things in this module | > referred to by the bit you are running. I'm sure it's doable, but I'm | > not looking fwd to it. | | I can see that compiling a module one set of declaration groups at a time | won't be much fun but given the way you split modules into lists of | declaration groups separated by top-level splices, it seems easy enough to | know what to compile: | | You have to compile all the code above the current top-level | splice or declaration group. | | -- | Alastair Reid | | | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

2 1

RE: Template Haskell...
by Simon Peyton-Jones 31 Oct '03

31 Oct '03

For some time now I've been saying that Tim and I are working on the design of some enhancements to Template Haskell. It's taken longer than I'd hoped, and we aren't done yet, but you can find a draft at http://research.microsoft.com/~simonpj/tmp/notes.ps The message below is a case in point. There's really no good way to do this in TH today, but it's one of the points addressed in our new design (see Section 5). Comments very welcome, folks. Nothing implemented yet, but it's getting near the front of the queue now. Simon | -----Original Message----- | From: glasgow-haskell-users-bounces(a)haskell.org [mailto:glasgow-haskell-users- | bounces(a)haskell.org] On Behalf Of MR K P SCHUPKE | Sent: 29 October 2003 17:46 | To: glasgow-haskell-users(a)haskell.org | Subject: Template Haskell... | | | Okay, I have got my template working, but its extremely unreadable... could | anyone tell me how to make this look more like normal Haskell code? | | stringType :: String -> Q [Dec] | stringType s = do | x <- gensym "x" | return [ | Newtype [] s [] (Constr s [(NonStrict,Tcon (TconName "String"))]) [], | Proto ("show"++s) (Tapp (Tapp (Tcon Arrow) (Tcon (TconName s))) (Tcon (TconName | "ShowS"))), | Fun ("show"++s) [Clause [Pcon s [Pvar x]] (Normal (App (Var "showString") (Var x))) []], | Instance [] (Tapp (Tcon (TconName "Show")) (Tcon (TconName s))) [ | Fun "showsPrec" [Clause [Pwild,Pvar x] (Normal (App (Var ("show"++s)) (Var x))) []]] ] | _______________________________________________ | Glasgow-haskell-users mailing list | Glasgow-haskell-users(a)haskell.org | http://www.haskell.org/mailman/listinfo/glasgow-haskell-users

4 6

RE: [Template-haskell] RE: Template Haskell...
by Simon Peyton-Jones 31 Oct '03

31 Oct '03

Trouble is, that's thoroughly awkward one to implement, because it means compiling the transitive closure of all the things in this module referred to by the bit you are running. I'm sure it's doable, but I'm not looking fwd to it. S | -----Original Message----- | From: template-haskell-bounces(a)haskell.org [mailto:template-haskell-bounces@haskell.org] On | Behalf Of Alastair Reid | Sent: 31 October 2003 17:21 | To: Simon Peyton-Jones; MR K P SCHUPKE; template-haskell(a)haskell.org | Subject: Re: [Template-haskell] RE: Template Haskell... | | The other big thing on my wish list is to relax the requirement that templates | go in a separate module from code that invokes the template. | | In Template Greencard, this is a major hassle because you have to put the code | to handle C types (you typically define a new template for each C type) in a | separate module from the code to handle C functions. | | -- | Alastair Reid | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

2 1

RE: Template Haskell...
by Simon Peyton-Jones 31 Oct '03

31 Oct '03

| stringType :: String -> Q [Dec] | stringType s = [| | newtype $s = $s String | show$s :: $s -> ShowS | show$s ($s x) = showString x | instance Show $s where | showsPrec _ x = show$s x | instance Eq $s where | ($s x) ($s y) = (x==y) | |] Yes, that's part of what we had in mind (see Section 5 of http://research.microsoft.com/~simonpj/tmp/notes.ps) You'd have to say: stringType :: String -> Q [Dec] stringType s = [| newtype $tc_var = $con_var String $show_var :: $tc_var -> ShowS $show_var ($con_var x) = showString x instance Show $tc_var where showsPrec _ x = $show_var x instance Eq $tc_var where ($con_var x) ($con_var y) = (x==y) |] where tc_var = mkVar s con_var = mkVar s show_var = mkVar ("show" ++ s)

1 0

RE: [Template-haskell] RE: [ ghc-Bugs-820778 ] Malformed Predicate w/ Template Haskell
by Simon Peyton-Jones 31 Oct '03

31 Oct '03

I was wrong. Multi-parameter classes are there. What was wrong was that Jon Cast's program constructed the predicate varT "Flatten" `appT` t whereas he should have used "conT". So there are two issues really: 1. It is in fact legal to have predicates like (m Int) forall m. (m Int) => ... but hsSyn/Convert.lhs didn't handle that. I've fixed that. 2. But it's really an error to allow (varT "T") or (conT "x") at all. Haskell does not allow lower-case type constructors or upper case type variables. So, should varT, conT test and fall over? Or should we instead remove the distinction between varT and conT? Simon | -----Original Message----- | From: Wolfgang Thaller [mailto:wolfgang.thaller@gmx.net] | Sent: 30 October 2003 21:24 | To: Simon Peyton-Jones | Cc: <template-haskell(a)haskell.org> <template-haskell(a)haskell.org> | Subject: Re: [Template-haskell] RE: [ ghc-Bugs-820778 ] Malformed Predicate w/ Template Haskell | | > TH maestros | > | > This bug turns out to be simply that Template Haskell is only set up | > for | > Haskell 98, whereas Jon Cast wants to manipulate multi-parameter type | > clases. | > | > Should we add multi-param type classes to THSyntax? Does anyone feel | > like doing it? It's a fairly routine matter, but it does mean changing | > the data type. (Another reason to use bracket syntax!) | > | > Simon | | Hmmm... I've been using some simple multi-param type classes (no | fundeps) with Template Haskell and GHC from the STABLE cvs tree, and | I've experienced no problems, so I thought they were supported. | They *are* a very useful feature that I don't think I could do without | - what needs to be done to keep them at least as supported as they are | now? | | Cheers, | | Wolfgang |

1 0

RE: [ ghc-Bugs-820778 ] Malformed Predicate w/ Template Haskell
by Simon Peyton-Jones 30 Oct '03

30 Oct '03

TH maestros This bug turns out to be simply that Template Haskell is only set up for Haskell 98, whereas Jon Cast wants to manipulate multi-parameter type clases. Should we add multi-param type classes to THSyntax? Does anyone feel like doing it? It's a fairly routine matter, but it does mean changing the data type. (Another reason to use bracket syntax!) Simon | -----Original Message----- | From: glasgow-haskell-bugs-bounces(a)haskell.org [mailto:glasgow-haskell-bugs- | bounces(a)haskell.org] On Behalf Of SourceForge.net | Sent: 09 October 2003 18:51 | To: noreply(a)sourceforge.net | Subject: [ ghc-Bugs-820778 ] Malformed Predicate w/ Template Haskell | | Bugs item #820778, was opened at 2003-10-09 12:51 | Message generated for change (Tracker Item Submitted) made by Item Submitter | You can respond by visiting: | https://sourceforge.net/tracker/?func=detail&atid=108032&aid=820778&grou p_id=8032 | | Category: Compiler (Type checker) | Group: 6.0.1 | Status: Open | Resolution: None | Priority: 5 | Submitted By: Jon Cast (jcast) | Assigned to: Nobody/Anonymous (nobody) | Summary: Malformed Predicate w/ Template Haskell | | Initial Comment: | The following two modules: | | --- Cut --- | | module ScratchTemplates where | | import Language.Haskell.THSyntax | | newtype Interaction a = Interaction a deriving Show | | ret = Interaction | | instance Monad Interaction where | return = Interaction | Interaction x >>= f = f x | | instance Functor Interaction where | fmap f x = x >>= return . f | | interactionT t = tcon (TconName "Interaction") `tapp` t | | class Flatten a b | a -> b where | flatten :: a -> b | | flattenT :: TypQ -> TypQ -> TypQ | flattenT t t' = tvar "Flatten" `tapp` t `tapp` t | | baseType t = sequence [ | inst (return []) (flattenT t t) | [val (pvar "flatten") (normal (var "id")) []], | inst (return []) (flattenT (interactionT t) | (interactionT t)) | [val (pvar "flatten") (normal (var "id")) []]] | | instance Flatten a b => | Flatten (Interaction (Interaction a)) | (Interaction b) where | flatten a = a >>= id >>= return . flatten | | module Main where | | import Monad | import ScratchTemplates | import Language.Haskell.THSyntax | | $(baseType (tcon (Tuple 0))) | | instance Flatten String String where | flatten a = a | | instance Flatten (Interaction String) (Interaction | String) where | flatten a = a | | instance Flatten b c => Combine String b (String, c) where | combine a b = liftM2 (,) a (fmap flatten b) | | instance Flatten Int Int where | flatten a = a | | class Combine a b c | a b -> c where | combine :: Interaction a -> Interaction b -> | Interaction c | | instance Combine () b b where | combine a b = b | | instance Flatten b c => Combine Int b (Int, c) where | combine a b = do | x <- a | y <- fmap flatten b | return (x, y) | | instance (Flatten b c, Combine a c d) => | Flatten (Interaction a, Interaction b) | (Interaction d) where | flatten (a, b) = combine a (fmap flatten b) | | main = main | | --- Cut here --- | | loaded into ghci -fglasgow-exts produce the following | error message: | | Compiling ScratchTemplates ( ScratchTemplates.hs, | interpreted ) | Compiling Main ( scratch.hs, interpreted ) | ghc-6.0.1: panic! (the `impossible' happened, GHC | version 6.0.1): | Malformed predicate | | Please report it as a compiler bug to | glasgow-haskell-bugs(a)haskell.org, | or http://sourceforge.net/projects/ghc/. | | | ---------------------------------------------------------------------- | | You can respond by visiting: | https://sourceforge.net/tracker/?func=detail&atid=108032&aid=820778&grou p_id=8032 | _______________________________________________ | Glasgow-haskell-bugs mailing list | Glasgow-haskell-bugs(a)haskell.org | http://www.haskell.org/mailman/listinfo/glasgow-haskell-bugs

2 1

RE: [Template-haskell] RE: Template Haskell...
by Simon Peyton-Jones 30 Oct '03

30 Oct '03

Now is the time to discuss this interface, because I'll implement it in the next "round" of TH. I had in mind that a particular run might cause multiple errors (error recovery is good) and warnings. So I was thinking of report :: Bool -> String -> Q () -- Report an error (True) or warning (False) This would not fail, though, just log a report. (It would not print it immediately, just accumulate it.) To fail, use the monadic fail. fail :: String -> Q () When recovering, you may want to suppress errors and/or warnings or you may not recover :: Q a -> Q a -> Q a -- Retain errors and warnings recoverQuietly :: Q a -> Q a -> Q a -- Discard errors and warnings I don't think we want Exceptions here. And I'm sceptical about whether the recovery code wants to inspect the errors and warnings. Just possibly, the recovery code could get the String passed to 'fail'. Personally I like the recovery code (= handler) to be the first argument, because it's usually small. I'm a bit uncertain about your failWithEx. Maybe a more elaborated version of report? I wonder if it's worth it. Simon | -----Original Message----- | From: Alastair Reid [mailto:alastair@reid-consulting-uk.ltd.uk] | Sent: 30 October 2003 10:05 | To: Simon Peyton-Jones; template-haskell(a)haskell.org | Subject: Re: [Template-haskell] RE: Template Haskell... | | | > f 0 = failWith "Postitive n required | > f n = [| \x -> x+n |] | > ....$(f 0)..... | > | > would elicit the error message | > | > Foo.hs:8: Error in splice $(f 0): | > Positive n required | > | > Is that what you want? | | I'd like: | | 1) To be able to write the function that formats the error message. | That is, the bit that adds in "Error in splice $(f 0):" | | Possible interface: | | --| Raise a TH exception | -- First argument uses the splice string to produce | -- an error string | failWithEx :: (String -> Q String) -> Q a | | failWith msg = failWithEx (\ splice -> | return ( "Error in splice " ++ splice ++ ":" | ++ "\n" ++ msg) | | 2) To be able to catch errors resulting from compiling the spliced code. | If we deliberately introduce an error: | | f n = [| \x -> x+'n' |] | ....$(f 3).... | | we get this error message: | | Couldn't match `Int' against `Char' | Expected type: Int | Inferred type: Char | In the second argument of `(+)', namely 'a' | In a lambda abstraction: \ x'0 -> (x'0 + 'a') | | I'd like the option of replacing that message with: | | Foo.hs:8: Uncaught Template Greencard error while expanding '$(f 3)' | Please report it as a bug | | The most obvious way to do this is to allow the exception to | be caught. | | Possible interface: | | --| Though this has the type of a normal exception catching function, | -- its semantics is (I think) a bit different because it catches | -- exceptions triggered by splicing its first argument into the | -- module and lets the handler offer up n alternative value to splice | -- in. | -- (For implementation reasons, it might be necessary to restrict | -- its use to top-level splices? - I'm guessing that this is the only | -- case where it's possible to unambiguously place the blame on | -- the splice.) | catchQ :: Q a -> (Exception -> Q a) -> Q a | | Using this, I'd rewrite | | f :: Int -> Q Exp | f n = catchQ (\ ex -> failWithEx (\ splice -> return "Uncaught ...")) | (f' n) | | f' 0 = failWith "Postitive n required | f' n = [| \x -> x+n |] | | | -- | Alastair Reid www.haskell-consulting.com |

2 1

RE: [Template-haskell] RE: Template Haskell...
by Simon Peyton-Jones 30 Oct '03

30 Oct '03

| I have one meta-function that generates declarations; and I have | another meta function that needs to know what definitions generated by | the first meta function there are (accross module boundaries). I'm not sure what you're asking for here. Some kind of monadic function that stores persistent state, that persists across multiple compilations? Presumably held in the file system? Some kind of database? I suppose you could write a library using strings only that would support write :: FileName -> String -> String -> IO () read :: FileName -> String -> IO String So (write f key val) writes the (key,value) pair into the file f; and read gets it back. Now you could use those in Q (because Q supports IO). Alastair wants per-module persistence. I'm sceptical about that because TH makes absolutely no guarantees about which order things will be evaluated in. So how would you know which effect occurs first? In both cases I feel I'm missing the point. | reifyImportedModules :: [String] -- or Q [String] | reifyCurrentModuleName :: String -- or Q String The latter seems sensible; but what should the former return? Just the *direct* imports? Do-able anyway. Simon

2 1

RE: [Template-haskell] TH bug report
by Simon Peyton-Jones 30 Oct '03

30 Oct '03

Likewise, now fixed in the HEAD. Simon | -----Original Message----- | From: template-haskell-bounces(a)haskell.org [mailto:template-haskell-bounces@haskell.org] On | Behalf Of Sean Seefried | Sent: 16 October 2003 12:55 | To: template-haskell(a)haskell.org | Subject: [Template-haskell] TH bug report | | Dear Template Haskell users, | | I just wrote a short program with this declaration and got the | following error message. | | ----- | d_class = [d| class Classy a b where | f :: a -> b | | instance Classy Int Bool where | f x = if x == 0 then True else False | |] | ------ | | | Class `Test.Classy' does not have a method `f' | In the instance declaration for `Test.Classy Int Bool' | In the definition of `d_class': | d_class = [d| | class Test.Classy a b where { | Test.f :: a -> b {- has default method -}; } | | instance {Test.Classy Int Bool} where | [] | f x y = if x == 0 then True else False |] | | ------ | | This doesn't seem like correct behaviour to me. | | Sean | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

1 0