- template-haskell - Haskell.org

reifyDecl problem
by Dmitry Malenko 22 Jul '03

22 Jul '03

Hi, All! In test code given below trying to reifyDecl function or constant declaration couse GHC to panic. Both CVS HEAD and 6.0. Am I mising something in reification of function declarations or is this reakky a bug in GHC? [dima@farside tmp]$ ghc --make -fglasgow-exts Main.hs Chasing modules from: Main.hs Compiling Main ( ./Main.hs, ./Main.o ) ghc-6.1: panic! (the `impossible' happened, GHC version 6.1): dsReify reifyDecl Main.l {- v rcA -} Please report it as a compiler bug to glasgow-haskell-bugs(a)haskell.org, or http://sourceforge.net/projects/ghc/. [dima@farside tmp]$ ghc-6.0 --make -fglasgow-exts Main.hs Chasing modules from: Main.hs Compiling Main ( Main.hs, ./Main.o ) ghc-6.0: panic! (the `impossible' happened, GHC version 6.0): dsReify reifyDecl Main.l {- v rcz -} Please report it as a compiler bug to glasgow-haskell-bugs(a)haskell.org, or http://sourceforge.net/projects/ghc/. \begin{code} import IO import Language.Haskell.THSyntax data T = A String | B l = A "kuku" f x = x k = reifyDecl l main :: IO () main = do x <- unQ k putStrLn (show x) \end{code} -- Best regards, Dmitry Malenko +----------------------------------------------------+ Registered Linux user #258004 ALT Linux Team http://www.altlinux.ru +----------------------------------------------------+ Marriage, n.: The evil aye.

2 3

Profiling with Template Haskell (continued)
by Sean Seefried 19 Jul '03

19 Jul '03

Hi all, I've been thinking about the profiling problem a little bit during the night and I've come up with some ideas and queries. I wish to clarify the following. There are three forms of a standard library aren't there? a) static library without profiling (e.g. libHSbase.a) b) static library with profiling (e.g. libHSbase_p.a) c) an equivalent object file for including the library in GHCi and during splicing in Template Haskell. (e.g. HSbase.o) When a module that contains splicing is compiled it seems to me that the third type of library is linked in (if it exists), followed by a an attempt to link in in a shared library. (e.g. libHSbase.so). Say we have a file Main.hs which includes splices from Splices.hs. Say we are just about to compile Main.hs and Splices.o exists. Then the symbols from Splices.o will be linked in during the splicing process right? But this is going to fail if Splices.hs was compiled with profiling on. And why is this? Splices.o will contain the undefined symbol '_CCS' if it is compiled with '-prof'. So when we link it in during the splicing process we are going to need this symbol to be defined somewhere. Well, I've had a brief look at the standard libraries that come with GHC and none of the .o forms of the libraries (type c above) has this symbol defined in them, but the symbol _is_ defined in all the static libraries that we built with profiling on (type b above). It seems to me that we require two types of .o library - one in which profiling was included and one it which it was not. Otherwise how can we compile programs using Template Haskell using the '-prof' option? Sean

1 0

Profiling with Template Haskell
by Sean Seefried 18 Jul '03

18 Jul '03

Hi all, I'd just like to find out what your experiences with profiling TH programs are? I'm not sure GHC-6.0 accomodate profiling when Template Haskell is involved. A really simple example that doesn't work is: ghc -prof -fglasgow-exts -make Main.hs applied to ----------------- {- Splices.hs -} module Splices where import Language.Haskell.THSyntax d_fun = [d| fun = putStrLn "I am a function" |] ----------------- {- Main.hs -} module Main where import Splices $(d_fun) main = fun ---------------- The output is : Chasing modules from: Main.hs Skipping Splices ( Splices.hs, ./Splices.o ) Compiling Main ( Main.hs, ./Main.o ) Loading package base ... linking ... done. Loading package haskell98 ... linking ... done. Loading package haskell-src ... linking ... done. ./Splices.o: unknown symbol `_CCCS' I'll bet that _CCCS is a cost center symbol that is (correctly) added to Splices.o. This symbol is present in many of the standard libraries (compiled with profiling support enabled. e.g. libHSbase_p.a contains the symbol) Now I know that profiling splicing doesn't make too much sense. That is not what I wish to do though. I wish to profile the final executable. I'm aware that when splicing much of the functionality of GHCi is used. Consider the three lines from the input above: Loading package base ... linking ... done. Loading package haskell98 ... linking ... done. Loading package haskell-src ... linking ... done. I think these are spat out from Linker.lhs. (It resides in the ghc/compiler/ghci directory of the GHC source.) Of course, at this point in compilation "_CCCS" is undefined. Is there anyway that we can get the linker to ignore profiling symbols during this phase of the compilation? How are we profile programs that use Template Haskell otherwise? Sean

1 0

re: newbie question
by Isaac Jones 09 Jul '03

09 Jul '03

> [Isaac, you need to join the TH list so you can post to it without > me having to intervene.] Done > Your original makeSum looked better. OK, thats what I was hoping. > Solution: use the "smart constructors" from the paper. More like > this: > genSummers n = fun ("makeSum" ++ (show i)) [clause [] (normal > (makeSum i)) [] ] Thanks, for some reason I was blind to the combination of using the "smart constructors" in together with sequenceQ. I thought I had tried every combination to make the types work out. Here's my solution below. peace, isaac \begin{code} -- |Given a size, n and n expressions, sum them up, so: -- > $(makeSum 4) 1 2 3 10 -- => 16 -- > $(makeSum 4) 1.0 2.2 3.4 10.1 -- => 16.7 makeSum :: Int -> ExpQ makeSum n = lam aPats (sumExps aVars) where -- create the symbols we'll need: aPats ::[Pat] aVars ::[ExpQ] (aPats,aVars) = genPE "num" n sumExps :: [ExpQ] -> ExpQ sumExps (h:t) = [| $h + $(sumExps t) |] sumExps [] = [| 0 |] -- |Bring functions named makeSumX into scope where X is in [1..n] genSummers :: Int -> Q [Dec] genSummers n = sequenceQ [fun ("makeSum" ++ (show i)) [clause [] (normal (makeSum i)) [] ] | i <- [1..n] ] -- Then in a different file, I can say -- $(genSummers 10) -- to bring makeSum1, makeSum2, etc into scope \end{code}

1 0

RE: [Template-haskell] newbie question
by Simon Peyton-Jones 09 Jul '03

09 Jul '03

[Isaac, you need to join the TH list so you can post to it without me having to intervene.] | > genSummers n = returnQ [Fun ("makeSum" ++ (show i)) [Clause [] (Normal $(makeSum i)) [] ] | i | <- [1..n] ] | | But actually, I run into a stage restriction. You don't want a splice there! But if you remove it, (makeSum i) returns an ExpQ, whereas Normal wants an Exp. | > makeSumE :: Int -> Exp If you want to generate fresh (rather than fixed) variable names in makeSum, it definitely needs to return an ExpQ, not an Exp. An Exp is simply a data structure. An ExpQ (= Q Exp) is a monadic computation which can generate fresh names. Usually better. Your original makeSum looked better. | > genSummers n = returnQ [Fun ("makeSum" ++ (show i)) [Clause [] (Normal (makeSumE i)) [] ] | i | <- [1..n] ] if makeSum returns an ExpQ, you can't do this for the reason above. Solution: use the "smart constructors" from the paper. More like this: genSummers n = fun ("makeSum" ++ (show i)) [clause [] (normal (makeSum i)) [] ] Simon

1 0

newbie question
by Isaac Jones 08 Jul '03

08 Jul '03

Greetings, I'm new to Template Haskell and am trying to work out some examples. I successfully used this function (makeSum n) to generate a function that takes n arguments. \begin{code} -- |Given a size, n and n expressions, sum them up, so: -- > $(makeSum 4) 1 2 3 10 -- => 16 -- > $(makeSum 4) 1.0 2.2 3.4 10.1 -- => 16.7 makeSum :: Int -> ExpQ makeSum n = lam aPats (sumExps aVars) where -- create the symbols we'll need: aPats ::[Pat] aVars ::[ExpQ] (aPats,aVars) = genPE "num" n sumExps :: [ExpQ] -> ExpQ sumExps (h:t) = [| $h + $(sumExps t) |] sumExps [] = [| 0 |] \end{code} Now I would like to bring a bunch of versions of this function into scope, something like > $(genSummers 10) where genSummers :: Int -> Q [Dec] and brings into scope: makeSum0 :: Int ... makeSum2 :: Int -> Int -> Int ... makeSum10 :: ... So this seems to make sense: > genSummers n = returnQ [Fun ("makeSum" ++ (show i)) [Clause [] (Normal $(makeSum i)) [] ] | i <- [1..n] ] But actually, I run into a stage restriction. Now I can create a function: > makeSumE :: Int -> Exp and say: > genSummers n = returnQ [Fun ("makeSum" ++ (show i)) [Clause [] (Normal (makeSumE i)) [] ] | i <- [1..n] ] But how to define makeSumE? I try this: \begin{code} makeSumE :: Int -> Exp makeSumE n = Lam aPats (sumExps aVars) where -- create the symbols we'll need: aPats ::[Pat] aVars ::[Exp] (aPats,aVars) = genPE' "num" n sumExps :: [Exp] -> Exp sumExps (h:t) = [| $h + $(sumExps t) |] --oops, can't do that sumExps [] = Lit $ Integer 0 \end{code} But alas, the commented line is not the right type. So how do I write genSummers? peace, isaac ps. I implemented the printf and sel examples from the paper with the real stuff from the GHC6 library, and that code can be found on the wiki: http://www.haskell.org/hawiki/TemplateHaskell Maybe when I come up with a handful of nice examples I can add them to the haddock for the Language.Haskell.THSyntax

1 0

RE: [Template-haskell] reifyType function
by Simon Peyton-Jones 07 Jul '03

07 Jul '03

I think you'll find that class Typeable, defined in Data.Dynamic, is pretty much exactly the class you describe. It's indeed a good thing. Simon | -----Original Message----- | From: template-haskell-admin(a)haskell.org [mailto:template-haskell-admin@haskell.org] On Behalf Of | Andre Pang | Sent: 07 July 2003 09:55 | To: template-haskell(a)haskell.org | Subject: [Template-haskell] reifyType function | | Hi all, | | Sean Seefried and I managed to implement a reifyType function, which | we're calling rType since there's already that annoying built-in | reifyType identifier ;). It's defined in a ReifyType module which | looks like thus: | | --8<-- | module ReifyType | where | | import Data.Dynamic | import Language.Haskell.THSyntax | | class ReifyType a where | rType :: a -> Typ | | instance (ReifyType a, ReifyType b) => ReifyType (a, b) where | rType (_ :: (t, u)) = Tapp (Tapp (Tcon (Tuple 2)) (rType (undefined | :: t))) | (rType (undefined :: u)) | | instance ReifyType a => ReifyType [a] where | rType (_ :: [t]) = Tapp (Tcon List) (rType (undefined :: t)) | | instance Typeable a => ReifyType a where | rType (_ :: t) = (Tcon (TconName typeAsString)) | where | typeAsString = show $ typeOf (undefined :: t) | | instance (ReifyType a, ReifyType b) => ReifyType (a->b) where | rType (_ :: t -> u) | = (Tapp (rType (undefined :: t)) (rType (undefined :: u))) | --8<-- | | An example of how to use it: | | 18:48 ~/Desktop % ghci -fglasgow-exts -fallow-overlapping-instances | -fallow-undecidable-instances ReifyType.hs | Type.hs) | ... | Loading package base ... linking ... done. | Compiling ReifyType ( ReifyType.hs, interpreted ) | Ok, modules loaded: ReifyType. | *ReifyType> rType Char.toLower | Loading package haskell98 ... linking ... done. | Loading package haskell-src ... linking ... done. | Tapp (Tcon (TconName "Char")) (Tcon (TconName "Char")) | *ReifyType> rType ((+) :: (Int -> Int -> Int)) | Tapp (Tcon (TconName "Int")) (Tapp (Tcon (TconName "Int")) (Tcon | (TconName "Int"))) | *ReifyType> rType "foobar" | Tapp (Tcon List) (Tcon (TconName "Char")) | *ReifyType> | | The major restriction is that you're limited to using it on monomorphic | types (since the typeOf function only works on monomorphic types), but | otherwise, it seems to work remarkably well. | | | -- | % Andre Pang : just.your.average.bounty.hunter | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

1 0

reifyType function
by Andre Pang 07 Jul '03

07 Jul '03

Hi all, Sean Seefried and I managed to implement a reifyType function, which we're calling rType since there's already that annoying built-in reifyType identifier ;). It's defined in a ReifyType module which looks like thus: --8<-- module ReifyType where import Data.Dynamic import Language.Haskell.THSyntax class ReifyType a where rType :: a -> Typ instance (ReifyType a, ReifyType b) => ReifyType (a, b) where rType (_ :: (t, u)) = Tapp (Tapp (Tcon (Tuple 2)) (rType (undefined :: t))) (rType (undefined :: u)) instance ReifyType a => ReifyType [a] where rType (_ :: [t]) = Tapp (Tcon List) (rType (undefined :: t)) instance Typeable a => ReifyType a where rType (_ :: t) = (Tcon (TconName typeAsString)) where typeAsString = show $ typeOf (undefined :: t) instance (ReifyType a, ReifyType b) => ReifyType (a->b) where rType (_ :: t -> u) = (Tapp (rType (undefined :: t)) (rType (undefined :: u))) --8<-- An example of how to use it: 18:48 ~/Desktop % ghci -fglasgow-exts -fallow-overlapping-instances -fallow-undecidable-instances ReifyType.hs Type.hs) ... Loading package base ... linking ... done. Compiling ReifyType ( ReifyType.hs, interpreted ) Ok, modules loaded: ReifyType. *ReifyType> rType Char.toLower Loading package haskell98 ... linking ... done. Loading package haskell-src ... linking ... done. Tapp (Tcon (TconName "Char")) (Tcon (TconName "Char")) *ReifyType> rType ((+) :: (Int -> Int -> Int)) Tapp (Tcon (TconName "Int")) (Tapp (Tcon (TconName "Int")) (Tcon (TconName "Int"))) *ReifyType> rType "foobar" Tapp (Tcon List) (Tcon (TconName "Char")) *ReifyType> The major restriction is that you're limited to using it on monomorphic types (since the typeOf function only works on monomorphic types), but otherwise, it seems to work remarkably well. -- % Andre Pang : just.your.average.bounty.hunter

1 0

RE: Template Haskell, [p|...|]
by Simon Peyton-Jones 04 Jul '03

04 Jul '03

There's a separate Template Haskell mailing list, which it'd be worth ccing on this (are you on it)? Ian Lynagh has a home page for Template Haskell, at http://www.haskell.org/th/ [IAN: it'd be worth noting the current unimplemented features of TH on the home page, perhaps. And is the TH page linked from Haskell.org? Couldn't find the link, if it exists.] | trying to adapt the zipN-example in the paper | "Template Meta-programming for Haskell" by | Sheard and Peyton Jones to Language.Haskell.THSyntax | I found that quasi-quotation for patterns does not seem | to work with ghci-6.0, e.g., the following results in | "Parse error in pattern": | | pcons x xs = [p| $x : $xs |] Yes -- pattern splices are not implemented at all. The user manual should say this, but doesn't. There are good reasons for this, as you'll see by looking at the TH mailing list archive. | Trying to use the standard list representation by | | pcons x xs = Pcon "(:)" [x,xs] | | I got the error message | | Data constructor not in scope: `(:)' | tcLookupDataCon: `(:)' is not in scope You need to say "GHC.Base::" to name precisely the (:) defined by GHC. This is clearly Bad and Horrible, and is on the list for a radical clean up. Tim Sheard is working on a design document describing what we have in mind. Tim? Simon

2 1

RE: [Template-haskell] Re: Template Haskell - read function
by Simon Peyton-Jones 03 Jul '03

03 Jul '03

What about passing the type as the driving argument: f :: [String] -> (Int, Bool) f = $(mkReader [t| (Int,Bool) |]) mkReader :: Type -> ExpQ mkReader ty = ... | -----Original Message----- | From: template-haskell-admin(a)haskell.org [mailto:template-haskell-admin@haskell.org] On Behalf Of | Thomas L. Bevan | Sent: 02 July 2003 16:01 | To: template-haskell(a)haskell.org | Cc: haskell(a)haskell.org | Subject: [Template-haskell] Re: Template Haskell - read function | | -----BEGIN PGP SIGNED MESSAGE----- | Hash: SHA1 | | I have got a little further by defining the following functions and I now have a better defined question. | | - --Takes a list and converts it to a n-ary tuple | - --i.e. Generates functions like [String] -> (a,a,a) | listToTuple i = lam [Pvar "xs"] (tup ([ infixE (Just $ var "xs") (var "!!") (Just $ lit (Integer n)) | n <- | [0..(i-1)] ])) | | - --Casts an n-ary tuple of type (String,String,..) | - --i.e. Generates functions like (a,a,a) -> (Int,Bool,Int) | cast i = lam [Ptup pats] (tup [ app (var "read") v | v <- vars]) | where | pats = [ Pvar $ show n | n <- [1..i] ] | vars = [ var $ show n | n <- [1..i] ] | | So, I can now define a function f, | | f :: [String] -> (Int, Bool) | f = $(cast 2) . $(listToTuple 2) | | but I can still see no way to infer the size of the tuple purely from the declared type signature. | | Tom | | | | On Wed, 2 Jul 2003 11:56 am, Thomas L. Bevan wrote: | > Hi, | > | > I'm struggling to write the following function in Template Haskell. | > | > I have a phantom type, | > | > >data HTMLPage a = HTMLPage FilePath | > | > This type points to an HTML file, where 'a' refers to the return type of | > the posted form. | > So, mostly, I would expect types like | > HTMLPage (String, String, Date, Int) | > | > Where this represented a form the returned someone's first name, last name, | > dob and age. | > | > So, I want a function that will take the returned name/value pairs and cast | > them into the matching type. | > | > eg. | > | > >readForm :: Read a => [(String,String)] -> HTMLPage a -> a | > | > Can anyone give me any pointers or am I better off just abandoning this | > approach? | > | > Tom | > | > _______________________________________________ | > Haskell mailing list | > Haskell(a)haskell.org | > http://www.haskell.org/mailman/listinfo/haskell | -----BEGIN PGP SIGNATURE----- | Version: GnuPG v1.2.2 (GNU/Linux) | | iD8DBQE/AvOlYha8TWXIQwoRAju7AKCxXxFQ1gMLTIUt93UpXyIQRVdqMQCg0Ryo | FQK/bFrjQaV9fOyi6naeYEo= | =fuyq | -----END PGP SIGNATURE----- | | _______________________________________________ | template-haskell mailing list | template-haskell(a)haskell.org | http://www.haskell.org/mailman/listinfo/template-haskell

1 0