- template-haskell - Haskell.org

splicing types
by Robert Greayer 02 Jul '08

02 Jul '08

Hi, I've been using TH to implement a library that generates code in a 'foreign' language that corresponds to a haskell ADT, as well as the haskell & foreign code required to transmit (i.e. serialize and deserialize) values back and forth between a haskell program and the foreign program. I've run into some situations in which it would be useful for there to be a way to control the code generation declaratively by providing additional meta-data to the code generator, beyond just the ADT(s) themselves. For example, suppose in a group of ADTs, certain fields should be omitted when serialized, and therefore not represented in the 'foreign' types, e.g.: > data Bar { > val1 :: String, > val2 :: Int -- omit this in serialization > } As a 'first order' stab at handling this issue, I thought of using type aliases, e.g > type Omitted a = a ... > val2 :: Omitted Int which could be generalized to a sort of 'annotation type', e.g. > type Ann a b = a > type Omitted = () -- a particular annotation ... > val2 :: Ann Int Omitted you could have multiple annotations, e.g. > val2 :: Ann Int (Omitted,Ann1,Ann2) -- an Int with three annotations The code generator 'sees' the aliases, and can therefore act on the ones it understands. This works, but I immediately run into situations where more flexibility is needed. Indeed, in the example I've chose ('omit'), all works ok when serializing the data, but what about *de* serializing (in haskell)? Some value needs to be chosen for the omitted field. An arbitrary default of (say) zero may not be appropriate. What I'd really like to be able to do is parameterize my annotations with values. 'Omitted' would be parameterized with the default value to use, e.g. > type Omitted a = () ... > val2 :: Ann Int (Omitted 1000) But of course this doesn't work, as I'm dealing with types here, not expressions. I could do something extremely hokey (hokier even than this system of annotations), like: > type I1000 = () ... > val2 :: Ann Int (Omitted I1000) -- read as 'omitted, with default of 1000' The code generator would determine the default value based on the name of the type 'Omitted' is applied to. The user of the annotation system would have the ugly task of creating 'dummy' type aliases for any values that need passing (and it would be quite cumbersome to attempt a naming convention for strings, etc.) It's at this point that I had the (for me) clever idea of simply writing a 'type level encoder' for any haskell expression, and then splicing in the encoding at the appropriate point, e.g. my integer as a tuple-type of binary digits: (One,Zero,Zero,One) would be a type encoding of '9', given the existence of type (aliases) such as: > type One = () > type Zero = () A function to encode an integer into the TH.Syntax representation of such a tuple -- (AppT (AppT (AppT (AppT (TupleT 4) (ConT ''One)) (ConT ''Zero)) (ConT ''Zero)) (ConT ''One)) is fairly trivial, as is a function to decode it back into an integer. It should (I think) be possible to write a pair of functions: > encT :: Q Exp -> Q Type > decT :: Q Type -> Q Exp to encode/decode arbitrary expressions into/from types. which would then allow my annotations to look like: > val2 :: Ann Int (Omitted $(encT [|1000|])) and allow me to annotate types with just about anything else, as well, with the ugly details of encoding/decoding hidden from both the user of the annotation system, and any code generation system that makes use of annotations. Which I found quite pleasing, since this 'quasi-annotations' feature is probably more powerful than some similar, 'intentional' annotation features of other languages, despite (afaik) not being an envisaged use of the language features involved. But then I tried it out and found that I'm trying to splice into what is currently an invalid splice position for TH. (Indeed, on the very day that I decided to try my idea out concretely, the relevant ticket affecting type declarations as valid splice positions was downgraded to low priority, and disincluded from GHC 6.10 -- http://hackage.haskell.org/trac/ghc/ticket/1476) So I was wondering if 1) splicing types is inseparable from the (harder?) problem of splicing patterns and 2) if splicing types is something that will is likely at some point to be implemented (is it that a good solution isn't yet apparent, or that it's just not important enough for the goals of TH?) and 3) has this idea, or something similar, been explored (regardless of the fact that it won't work with TH as-implemented) before? Thanks, rcg

5 7

Is there an easier way to write [| $(..) $(..) $(..) |] ?
by Marc Weber 30 Jun '08

30 Jun '08

Right now I'm spending some time on exploring how haskell could be used to model a small in memory only RDBM system. (Final goal is to use it with HAppS state etc..) A db description looks like this: $(let cds = defaultTable { tblName = "cds" , columns = [ ("cdId", conT ''Int) , ("title", conT ''Int) ] , primary = PrimaryUniq [ "cdId" ] (MaxPKPlusOne 10) , indexes = [ Index "title" [] ] , tblStates = [ ( "nextCdId", [t| Int |], [| 0 |] ) ] } tracks = let a="a" in defaultTable { tblName = "tracks" , columns = [ ("trackId", conT ''Int ) , ("name", conT ''String) , ("cd", conT ''Int) -- foreign key ] , primary = PrimaryUniq [ "cd", "trackId" ] -- is there a nice way than using that many mkNameE (SetSubPKPlusOne 5) , indexes = [ Index "cd" [ IndexUnique "trackId" ] ] --the id is uniq foreach cd -- checks = [ foreignConstraint "cd" "cds" "id" ] -- triggers = [ InsertUpdate (Just ["cd"]) [| cdUpdateByPK ( updateNum_tracks (+1) ) . pk |] -- DeleteUpdate (Just ["cd"]) [| cdUpdateByPK ( updateNum_tracks (-1) ) . pk |] -- ] } db = defaultDB { dbName = "my" , tables = [ cds, tracks] , statistics = True } in createDB db) instead of the MaxPKPlusOne you can also use your custom function to get the next primary id: [| \row -> withNextIdStateFromCds $ do s <- get; put (s+1); return s |] This will get more complicated for sofisticated use cases SetSubPKPlusOne. The primary key is made up of the cdId and the trackId. Now I'd like to set the trackId to the smallest not yet used number. This results in something like row -> let cd = cdId row in let map = lookup cd (get index map here) in if null map then 1 else (+1).fst.findMAx map which is fine except that cdId and (get index map here) must use functions defined by createDB. So the only way to write this is cluttering everything up with $(varE $ mkName $ "cdId") which makes the code less readable.. So my question is: Would it make sense to ask ghc to take an unkown function, but instead of complaining rewrite it as varE $ mkName $ <name> ? Maybe one easy solution to achievie this is make haskell-src output an template haskell AST? Then you can get nice looking and readable code and still have most of the power of weriting template haskell ? Anyone thought about this? Mmh still thinking about how the query language should look like. I have something like printf syntax in mind... $(query "id > ?1 AND ?2 == text ") 7 "text" .. Marc Weber

1 0

using template haskell to implement pads for haskell?
by David Walker 30 Jun '08

30 Jun '08

hi, I am new to Haskell and even more so to Haskell templates -- if there is an obvious answer to my question, please just point me at the relevant URL. Thanks! (If you think I should email this query to a broader Haskell mailing list let me know too.) My friends and I are thinking about adding an extension to Haskell to implement a variant of the PADS domain-specific language. PADS is a convenient syntax to describe a file format and generate a bunch of tools for it such as parser, printer, xml translator, semi-structured query engine, statistical profiler, etc. (We also have tools to automatically infer descriptions from example data but that's not quite the point here.) See www.padsproj.org/ for lots more info and examples of PADS for C and PADS for O'Caml. The bottom line question is I'm wondering if I can or should implement my PADS extension using Template Haskell to support the syntactic extensions. If not Template Haskell, is there another Haskell toolkit I should know about? If Template Haskell isn't powerful enough, I'll probably just write a standalone compiler that parses my special syntax and spits out a file full of Haskell declarations (this would be a slight shame because then I would probably not support writing PADS declarations in the midst of other Haskell code). I've looked at simple Template Haskell examples from the Haskell wiki, such as the printf example, but I need to introduce a lot more syntax than that ... What do I need from Template Haskell? Well what I would like to do is add a bit of syntax to Haskell that allows users to define what looks like non-standard type declarations. The "compiler" for these non-standard type declarations will generate a collection of ordinary Haskell declarations that can be used by a programmer. The non-standard typing declarations will be a mixture of what looks like Haskell type declarations, Haskell code, perl-style syntax for regular expressions and perhaps some other stuff I'm not thinking of right now. For example, suppose I want to write a program that converts a file that contains a list of friends into XML (it's a bit of an artificial example so I can illustrate several features): 3 Simon;Peyton Jones John;Launchbury #Phil;Wadler The format starts with a number on the first line to indicate the number of entries in the file. Each line contains one entry which is a first name then a ';' then a last name. Some lines begin with a # -- they are commented out because I'm no longer friends with them. Naturally, Phil Wadler falls into that category. :-) ! The Haskell program I want to write to do this would look something like: ------------------------- {| pdata Line = Comment /#.*/ | Name {first::Pstr /;/, last ::Pstr /\n/} ptype Friends = (x::Pint, |{ x > 0 }|, /\n/, PlistFW x) |} friendsToXML :: String -> XML friendsToXML s = PADSTools.toXML Friends s ------------------------- Notice the following syntactic features: -- {| and |} are delimiters that begin/end pads code (I don't really care what the delimiters are as long as they are relatively concise. For instance, if the delimiters were $( ... ), for instance, that would be fine. -- inside {| and |}, we can jump back into Haskell by using the delimiters |{ and |} -- there are some built-in, pre-defined base types like Pstr (for parsing and printing strings) and Pint (for parsing and printing integers), PlistFW (which takes an argument x to specify the number of elements in the list) -- regular expressions /..../ show up in the middle of what would otherwise be Haskell type declarations -- there is syntax for declaring datatype-like things (introduced by pdata keyword) -- the declarations are dependent types in that there is binding (eg: the x::Pint in the "Friends" type -- the x is bound here) -- variables bound in pads code can then be used in Haskell code nested inside the declaration (eg: the Haskell expression x > 0 refers to the variable x, defined in the outer pads code). -- the outer Haskell code refers to declarations made inside the PADS code. (eg: the Haskell function "friendsToXML s = PADS.Tools.toXML Friends s" refers to Friends, where Friends would be bound to a datastructure generated by the compiler for the pads code. PADSTools is a module defined a priori that contains a number of functions such as toXML, parse, print, query, etc.) Anyway, if you have any comments on how I should handle the syntactic extensions, let me know. Thanks again, Dave

6 6

tuple (Int) == or != Int ?
by Marc Weber 30 Jun '08

30 Jun '08

Does ghc make difference beteen a tuple "(Int)" and a no tuple "Int" ? I'm confused about this error: -- packages: template-haskell {-# OPTIONS_GHC -XTemplateHaskell #-} module Main where import Language.Haskell.TH import System.IO import Language.Haskell.TH.Syntax class PrimaryKey tableRow pk | tableRow -> pk where pk :: tableRow -> pk data Row = Row { idV :: Int , b :: String } $( do let pks = ["idV"] row <- newName "row" {- || instance PrimaryKey Row ((GHC.Base.Int)) || where pk row_0 = (idV row_0) test.hs|15 col 3 error| || Couldn't match expected type `(Int)' against inferred type `Int' || In the expression: idV row[a1eY] || In the definition of `pk': pk row[a1eY] = idV row[a1eY] || In the definition for method `pk' -} i <- instanceD (cxt []) (appT (appT (conT $ mkName $ "PrimaryKey") (conT $ ''Row)) (appT (tupleT (length pks)) (conT ''Int))) [funD (mkName "pk") [clause [varP row] (normalB (tupE (map (\k -> (appE (varE $ mkName $ k) (varE row))) pks))) []]] runIO $ do putStrLn $ pprint $ i hFlush stdout return [i] ) main = return () Marc Weber

3 2

Custom patternmatching for ADTs and Emulating TH Pattern splicing (was quasiquoting and guards)
by Alfonso Acosta 27 Jun '08

27 Jun '08

On Wed, Jun 25, 2008 at 11:19 PM, Reid Barton <rwbarton(a)math.harvard.edu> wrote: > Hi all, > > I'd like to use quasiquotation to emulate bash's case statement in > Haskell. Nice Idea. I've been thinking about using quasiquoting patters for regular expression matching for a while. Never found the time to code it though. > I tried (ab)using view patterns, but > they're not yet supported by Template Haskell. Right, I think that would be the nicest approach (if they were supported of course and I would really like to see this implemented). Then, your initial expression ... example x = case x of [$rx|.*foo.*] -> "contains foo" _ -> "doesn't contain foo" Could be expanded to example x = case x of (match ".*foo.*" -> True) -> "contains foo" _ -> "doesn't contain foo" Sadly, I cannot think about any solution working with current version of GHC. I considered patternguards, but after all, they have the same problem you mentioned for standard ones ... -- Now, some unrequested comments about view patterns+quasiquotes: Pattern quasiquotes and patternviews match nicely, allowing to patternmatch ADT's using custom syntax. For example, imagine a vector ADT. It's closest view (against which standard patter matching is possible) would probably be a list. However, it would be more appropriate to be able to match using custom syntax other list patterns, say <1,2,3>, to patternmatch a vector with three specific elements. With quasiquoters and views one could do f :: VectorADT Int -> Result -- v is the quasiquoter for vectors f [$v|<1,2,3>] = ... which IMHO is much nicer than f :: VectorADT Int -> Result f (toList -> [1,2,3]) = ... In order to implement this, it would be required to * have view pattern support in TH. * have a Haskell pattern parser returning TH's AST (parseHaskellPat :: String -> Pat) (which as far as known no one has implemented yet). This parser could also serve to build a quasiquoter with which to emulate splicing patterns with Template Haskell, that is [p| |], which isn't currently implemented (see http://hackage.haskell.org/trac/ghc/ticket/1476) So, I think I'll get my hands dirty on it. My best bet is probably using Language.Haskell.Parser and then implement a translator from Language.Haskell.Syntax to Language.Haskell.TH.Syntax . Another option would be using GHC's Haskell parser and its translator from GHC's AST to Language.Haskell.TH.Syntax (basically steal the implementation of [| |]). However, since my knowledge of GHC's internals is almost null, I'm not sure if I should do that, whether it's even possible or if it would worth the effort. The GHC gurus can probably clarify this. What do think? I would certainly appreciate some feedback and suggestions before I start to code.

3 2

quasiquoting and guards
by Reid Barton 26 Jun '08

26 Jun '08

Hi all, I'd like to use quasiquotation to emulate bash's case statement in Haskell. That is, I'd like to turn example x = case x of [$rx|.*foo.*] -> "contains foo" _ -> "doesn't contain foo" into (assuming an appropriate match :: String -> String -> Bool) example x = case x of s | match ".*foo.*" s -> "contains foo" _ -> "doesn't contain foo" But it seems like I can't do so, because despite appearances, the difference between the two cases in the second example is not in "what's to the left of ->". Instead, the first has a GuardedB body while the second has a NormalB body. (Having reread the Haskell Report, I now understand why this is, but it was surprising at first.) Whatever my definition of the quasiquoter rx is, the first example is going to expand to something with two NormalB bodies, so I can't achieve the desired expansion. Is there a clever workaround? I tried (ab)using view patterns, but they're not yet supported by Template Haskell. Regards, Reid Barton

3 3

recover and get error message? - parsing th syntax trees
by Marc Weber 04 Jun '08

04 Jun '08

I'd like to implement a simple helper function -- helper pasring the reify output thChoice :: a -> [ a -> Q r ] -> Q r thChoice a list = thChoice' list where thChoice' [] = fail $ "no parser did match" thChoice' (p:ps) = (p a) `recover` (thChoice' ps) However there I can't get the result of why a parser has failed this way: thChoice :: [ a -> Q r ] -> Q r thChoice a list = thChoice' [] list where thChoice' errors [] = fail $ "no parser did match: error messages " ++ (show errors) thChoice' errors (p:ps) = (p a) `recover` \e -> (thChoice' (e:errors) ps) ^^ unfotunately recover doesn't support passing this \e To show a nice list expected either a) ... b) ... c) ... but no parser did match the passed arg ... I've also tried `catchError` but there was no instance.. Is there another way handling this or should I just use Either Error result and return . Left $ return . Right $ or put kind of ErrorMonad on top of the Q monad myself? My use case: Parse different settings specified by using different types such as UniqKey or (Key Foo ()) or relation settings type Tickets = Table (Autoinc, Surname, TestCase.Name) (Key Name (), Key Surname ()) (Rel Inbound Flights, Rel Outbound ( Maybe Flights) ) type <name> = Table <cols> <keys> <master tables> <keys> : the primary key field is added automatically example: key Foo (-> Map Foo row) double index (Foo2, Bar) (-> Map Foo2 ( Map Bar row ) ) ) ( UniqKey Foo , Key Foo2 ( Key Bar () ) ) <master tables>: ( TableMaster , Rel IdType TableMaster2 -- optional relation (eg a ticket may have a retour, but doesn't have to have) , Maybe TableMaster4 , (Rel IdType (Maybe TableMaster5)) ) Is there alreay a library providing this kind of error reporting for parsing haskell template syntax trees? Marc Weber

2 1

Can I reify types?
by Marc Weber 04 Jun '08

04 Jun '08

This doesn't work: -- packages: template-haskell {-# OPTIONS_GHC -XTemplateHaskell #-} module Main where import Language.Haskell.TH data A a = A a type C = A Int data ABC = ABC Int $(do a <- reify $ mkName "C" report False $ show a return [] ) main = print "" || [1 of 1] Compiling Main ( test.hs, test.o ) || test.hs|1| `C' is not in scope at a reify Using mkName "A" results in test.hs|1 error| || DataConI Main.A (ForallT [a_1627391370] [] (AppT (AppT ArrowT (VarT a_1627391370)) (AppT (ConT Main.A) (VarT a_1627391370)))) Main.A (Fixity 9 InfixL) as expected Why do I need it? I'd like to implement kind of very basic relational data representation the way IxSet is doing it but without dynamics.. It will look like this: type CDs = Table (Autoinc, Artist, Title, Year) -- col types (Artist, Title, Year) -- keys () -- is detail of type Tracks = Table (Autoinc, Title, RecordingDate) (Title, RecordingDate) (CDs) $(mkDB ["CDs","Tracks"]) To be able to automatically derive insert{CDs,Tracks} delete{CDs,Tracks} update{CDs,Tracks} functions I need to get information about those types.. Is this possible? Thanks Marc Weber

3 3

deriving data Foo = Foo { unFoo :: String } ?
by Marc Weber 25 May '08

25 May '08

============= TestX.hs ============================================== module TestX where import Language.Haskell.TH import Language.Haskell.TH.Syntax mkADT :: String -> String -> Q [Dec] mkADT n t = let n' = mkName n un = mkName $ "un" ++ n in return [DataD [] n' [] [RecC n' [(un,NotStrict,ConT un)]] []] ============= Main.hs ================================================ -- peckages: template-haskell {-# OPTIONS_GHC -XTemplateHaskell #-} module Main where import TestX $( mkADT "Test" "String") main = putStrLn . unTest $ Test "test" ============= error ================================================== test.hs|1 error| || Illegal type constructor or class name: `unTest' || When splicing generated code into the program ============= ======================================================= What am I doing wrong? Thanks Marc Weber

2 1

Language Extensions and TH
by Hugo Pacheco 08 Apr '08

08 Apr '08

Hi all, Is there a TH and recent GHC's extension type-indexed families interaction envisaged? Is it feasible to think of such support? I am not sure wether only Haskell 98 is supported or if any language extension is supported. Thanks, hugo

2 2