June 2008 - template-haskell

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