- template-haskell - Haskell.org

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

problem with quasi-quoting instance declaration
by Ganesh Sittampalam 11 Sep '03

11 Sep '03

Using 6.0.1 or the 20030903 CVS snapshot: ghc-6.1: panic! (the `impossible' happened, GHC version 6.1): Failed binder lookup: GHCziShow.show {- v r4H -} If I try to compile the following code. Commenting out the line defining show (but not the instance line itself) makes the error go away. Cheers, Ganesh module TH2 where code = [d| data Foo = Foo instance Show Foo where show Foo = "foo" |]

1 0

RE: [Template-haskell] Using a Typ as a Type
by Simon Peyton-Jones 04 Sep '03

04 Sep '03

OK, I see a bit better now. One question you raise (implicitly) is whether you can have splices inside splices: y = [| 4+5 |] f x = $(h $y) TH doesn't currently allow this, but there's no difficulty in principle. To see this, just substitute for y: f x = $(h $[| 4+5 |]) = $(h (4+5)) But you also try something that really won't work: f x = $x This is ill staged. TH must *run* the top-level splices. It can't run $x because it doesn't know x's value yet. So in your example, the line let x = f "1" :: $typ is ill-staged because TH can't run $typ, because type is lambda bound. I could just about imagine the following. Suppose your 'generate' was a TH function that *generated a TH function*. So the entire body of 'generate' is quoted. Then I could just about imagine how it might work. The type of generate would look something like | generate :: String -> Q Typ -> Q (Expr (Q [Dec])) (I'm imagining here that Expr is parameterised, which it isn't, but it helps documentation to say (Expr t) means an Expr of type t.) Then a call to generate would look like $($(generate ..)) It would execute by running generate to produce a TH program (essentially inlining only), typechecking that (this is where the overloading you want would be resolved) and then running it. A consequence would be that the TH data types (Expr, Dec etc) would need to get extra constructors to represent quotes, splices etc. Bottom line: today, definitely no. But I hadn't realised before that there could, just, be some benefit to repeated splices like $($(generate...)). I wonder if anyone else has come across this need? Simon | -----Original Message----- | From: Alastair Reid [mailto:alastair@reid-consulting-uk.ltd.uk] | Sent: 03 September 2003 16:06 | To: Simon Peyton-Jones; Alastair Reid; template-haskell(a)haskell.org | Subject: Re: [Template-haskell] Using a Typ as a Type | | > Perhaps the thing to | > do is to give a simple but concrete example of what you'd like to do. | | The following is a simplified version of what I tried to do in Template | Greencard. | | -- a new class | class X a where | -- member parameterized on result type | f :: String -> a | -- member parameterized by argument type | ctype :: a -> String | | -- instances for old types | instance X Int where | f = read | ctype _ = "HsInt" -- FFI-defined C type corresponding to Int | | -- instances for freshly defined types | newtype T = T Int | deriving Show -- included to make the example work | | instance X T where | f s = T (read s) | g (T x) = g x | | generate :: String -> Q Typ -> Q [Dec] | generate nm typ = do | | -- The next line contains the type splice. | -- Note that it is used to perform a compile-time dictionary | -- lookup not a runtime lookup. | -- I'm not wedded | let x = f "1" :: $typ | | -- Generate C code (should be written to a file, not stdout) | -- Code generated depends on type argument | qIO (putStrLn (ctype x ++ " " ++ nm ++ " = " ++ show x ++ ";\n") | | -- return a variable definition. | -- again, the definition returned depends on the type | -- because it uses 'x' which was produced as a result of | -- the compile-time dictionary lookup. | [d| $nm = $(literal x) |] | | | > Remember, the execution of TH program can be described by ordinary | > rewriting rules (replace the LHS of a function by the RHS of the | > function, suitably instantiated), augmented with the one extra rule | > $[| e |] = e | | Should this apply to types as well? | | -- | Alastair |

1 0

RE: [Template-haskell] Using a Typ as a Type
by Simon Peyton-Jones 04 Sep '03

04 Sep '03

Tim and I are working on this very thing right now. Stay tuned Simon | -----Original Message----- | From: Alastair Reid [mailto:alastair@reid-consulting-uk.ltd.uk] | Sent: 03 September 2003 16:17 | To: Simon Peyton-Jones; Alastair Reid; template-haskell(a)haskell.org | Subject: Re: [Template-haskell] Using a Typ as a Type | | On Wednesday 03 September 2003 2:19 pm, Simon Peyton-Jones wrote: | > | > TH doesn't support type splices today; that's one of the things I'm | > | > actively working on. But I'm not sure if this is what you meant. | | btw Something that would be very nice is if $ could be used to splice patterns | and declarations as well as expressions so that I could write: | | foo :: String -> Q [Dec] | foo x = [| \ $(pat x) -> $(var x) |] | | or | | bar :: Q Expr -> Q Dec -> Q [Dec] | bar e binding = [| let $binding in $e |] | | These examples aren't that compelling but I've had to code round not being | able to write code like this lots of times. | | -- | Alastair | | ps This is quite independent of my request for type splices. The above makes | it easier to write what you can already write whereas type splices extend the | power of TH to let you write things that aren't possible at the moment. | |

1 0

RE: [Template-haskell] Profiling with Template Haskell
by Simon Peyton-Jones 03 Sep '03

03 Sep '03

| The issue is this: | | how can one compile a program that uses TH | so that the resulting executable is profiled | | I'll call | C-code is code that runs at compile time | R-code is code that runs at runtime | | We aren't trying to profile C-code, only R-code. Further ruminations, following discussion with Simon M. Assume that a module M contains a mixture of C-code and R-code (which in general it can). Compile it both ways: ghc -c M.hs (generates M.o non-profiled, M.hi) ghc -c -prof -O M.hs -o C.p_o (generates M.p_o profiled, M.hi again) Now suppose module A is like this: module A where { import M( f ) $(f 3) h x = f x } A contains only R-code, so it need not be compiled without -prof. When we say ghc -c -prof -O A.hs GHC will load M.hi, then dynamically link the non-profiled M.o, and run it. Later you link A.o and M.p_o, and all should be well. NOTE that M.hi serves to describe both M.o and M.p_o. That's ok, because all the TH part needs (when typechecking $(f 3)) is the type of f, and that's the same in both M.o and M.p_o. It's important to compile M.hs with -prof *second* so that the profiled .hi file is the one that survives. If you are optimising, the unfolding should be the ones for R-code, not C-code. One other issue is this. TH/GHCi don't currently call the module-initialisation procedure after dynamically linking a module. This is really a bug. The module-init procedure registers foreign exports, so presumably that does not currently work in GHCi. The dynamic linker should really run the init procedures of the (root) modules it loads. Simon

1 0

RE: [Template-haskell] Using a Typ as a Type
by Simon Peyton-Jones 03 Sep '03

03 Sep '03

| > TH doesn't support type splices today; that's one of the things I'm | > actively working on. But I'm not sure if this is what you meant. | | It is but it is very important that: | | 1) We can do dictionary lookups using the spliced type. | | | 2) The lookup happen at compile time so that it can affects the | code being generated. | | 3) Instances declared in the code being compiled (like the DIS | instances above) can be found by this mechanism. That is, | I'm not interested in finding any DIS instances that might have | been present in the source code for ghc. Type splices will behave exactly like expression splices today. I'm not sure whether that fulfils your 1-3 reqts. Perhaps the thing to do is to give a simple but concrete example of what you'd like to do. I couldn't understand the example you gave last time, as I mentioned. Do you think it still says what you mean? Could you give a line by line explanation of what you think should take place? Remember, the execution of TH program can be described by ordinary rewriting rules (replace the LHS of a function by the RHS of the function, suitably instantiated), augmented with the one extra rule $[| e |] = e (Unless you use explicit do-notation.) Simon

2 2

RE: [Template-haskell] Using a Typ as a Type
by Simon Peyton-Jones 03 Sep '03

03 Sep '03

| Is there any way that I can use a Typ (i.e., a reified Type) as a Type inside | a template so that I can use the Typ to select an instance of a type class. | | For example, I'd like to be able to write (this doesn't parse): | | $(test [t[ Float ]] "1.0") | | test :: Q Typ -> String -> Q [Dec] | test qty x = do | ty <- qty | print (read x :: $ty) -- The ':: $ty' part is the important bit | return [] I've Sean's reply and Alastair's reply to that, and I still can't figure out what you are trying to do. The above code looks weird. test is a Q [Dec], but you are doing a print in the middle of it. Why? In principle you can certainly say: $(test [t| Float ]] "2.0") test :: Q Type -> String -> Q [Dec] test qty x = [| read (x::$qty) |] so that $(test [t| Float ]] "2.0") ===> read ("2.0" :: Float) TH doesn't support type splices today; that's one of the things I'm actively working on. But I'm not sure if this is what you meant. Simon

2 1

RE: [Template-haskell] Profiling with Template Haskell
by Simon Marlow 03 Sep '03

03 Sep '03

> | > Then, all you need do is > | > compile C-code without -prof > | > compile R-code with -prof > | > | But we only have one kind of "import", which imports a > module both at > compile-time and run-time. > | You'd be forced to link in the C-code modules in the final program, > and I'm pretty sure something will > | go wrong even if the program doesn't end up referring to > anything from > those modules. > > Ah... you mean the module initialisation tree will still kick > in. Hmm. > But if a module is pure C-code, the mod-init code will still work even > if it's compiled without -prof, wont' it? Admittedly, the c-module > would then a (redundant) part of the runtime executable I realised you'll get a link failure, because the init function contains the build tag, so it's impossible to link non-prof code with prof code (this is a safety feature :-). So, you still need to compile any module which contains compile-time code as both prof and non-prof. The latter will be used at compile time only. There might be some confusion over interface files: GHC will read the profiled interface, so it better be consistent with the non-prof interface, which describes the code we're going to load and run at compile time. One way which is guaranteed to work is to put the compile-time code into a package. Cheers, Simon

1 0