0
Template Haskell Tutorial                                      short, illustrated examples         from Illustrated Haskel...
Motivating example    fst(x,_)      = x    fst3(x,_,_)   = x    fst4(x,_,_,_) = x    …    print $ fst3 ("hello world"...
Template Haskell to the rescue!Usage:    {-# LANGUAGE TemplateHaskell #-}    print $ $(fstN 3) ("hello world", 1, 2)   ...
How to write it?-- FstN.hs{-# LANGUAGE TemplateHaskell #-}module FstN whereimport Language.Haskell.THfstN :: Q ExpfstN n =...
OK, how about explaining it? Every time you want to write something in TH, you start with:runQ [| ... |]    GHC will tel...
Writing fst3 in TH So we already have an Exp, how about those x_1?LamE [TupP [VarP x_1,WildP,WildP]] (VarE x_1)> :t (VarP...
Evolving fst3 into fstN    The following corresponds to the expression (x,_,_) -> xfst3 = do    x <- newName "x"    LamE ...
Using fstN    For technical reasons, splices must be defined in a      separate module.    So we need to create a new mo...
Quasi Quotes
Quasi Quotes    The [| … |] notation that you just used is the quasi quotes for Haskell       expression.    The content...
Quasi Quotes    When you do [| x -> x |], the string inside the      brackets is parsed by the Haskell compiler and      ...
Let’s do a simple example    We will build a structure to represent HTML documents    For simplicity, we omit attributes...
First, a simple HTML parser    We’ll sidetrack a bit and make a dead simple HTML parser      using Parsec    Our focus h...
A simple test for our parser$ ghci HTML.hs> parseTest tagNode "<html>Hello, <strong>TH</strong> world!</html>"Tag "html" [...
Now we can write our QuasiQuoter-- HTML.hs                                                The QuasiQuoter takes 4Html :: ...
    htmlExpr is supposed to parse the contents within       [html| … |] and give back an ExphtmlExpr :: String -> Q Expht...
Let’s compile it!$ ghc HTML.hsError: No instance for (Lift Node) arising fromarising of `tag’…    What is that? Well mayb...
Let’s try it out-- HTMLTest.hs{-# LANGUAGE TemplateHaskell , QuasiQuotes #-}import HTMLmain = print [html|<html>Hello, <st...
Quasi quoting for patterns    Now let’s try to do some operations on our HTML       structure    In this example we will...
Let’s make a simple converter-- HTMLTest.hsmarkdown (Tag "strong" children)                     =    "**" ++ concatMap mar...
Add a pattern parser to our QuasiQuoter -- HTML.hs html :: QuasiQuoter html = QuasiQuoter htmlExpr htmlPat   undefined und...
Asking GHC again…    Now how do we write the “rest” case? Let’s ask GHC> runQ [p| Tag "strong" chlidren |]ConP HTML.Tag [...
Some explanationshtmlPat (<:rest) = return $    ConP (mkName "HTML.Tag”)        [ LitP (StringL (init rest))        , VarP...
Let’s test it out!-- HTMLTest.hs{-# LANGUAGE TemplateHaskell , QuasiQuotes #-}import HTMLdoc = [html|<html>Hello, <strong>...
Summary    Use runQ to have GHC write the splice for you    Then just fix it up by following the type    Illustrated Has...
Upcoming SlideShare
Loading in...5
×

Template Haskell Tutorial

8,165

Published on

Published in: Technology, Education
0 Comments
9 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
8,165
On Slideshare
0
From Embeds
0
Number of Embeds
4
Actions
Shares
0
Downloads
53
Comments
0
Likes
9
Embeds 0
No embeds

No notes for slide

Transcript of "Template Haskell Tutorial"

  1. 1. Template Haskell Tutorial short, illustrated examples from Illustrated Haskell <http://illustratedhaskell.org>
  2. 2. Motivating example fst(x,_) = x fst3(x,_,_) = x fst4(x,_,_,_) = x … print $ fst3 ("hello world", 1, 2) print $ fst4 ("hello world", 1, 2, 3)So repetitive! Illustrated Haskell <http://illustratedhaskell.org>
  3. 3. Template Haskell to the rescue!Usage: {-# LANGUAGE TemplateHaskell #-} print $ $(fstN 3) ("hello world", 1, 2) print $ $(fstN 4) ("hello world", 1, 2, 3) Illustrated Haskell <http://illustratedhaskell.org>
  4. 4. How to write it?-- FstN.hs{-# LANGUAGE TemplateHaskell #-}module FstN whereimport Language.Haskell.THfstN :: Q ExpfstN n = do x <- newName "x” return $ LamE [TupP $ VarP x : replicate (n-1) WildP] (VarE x)Illustrated Haskell <http://illustratedhaskell.org>
  5. 5. OK, how about explaining it? Every time you want to write something in TH, you start with:runQ [| ... |] GHC will tell you how to write it. For example, if we wanted to write a splice that will produce (x,_,_) -> x$ ghci – fth> :m +Language.Haskell.TH> runQ [| (x,_,_) -> x |]LamE [TupP [VarP x_1,WildP,WildP]] (VarE x_1)> :t itit :: Exp That’s it, no need to remember anything! Just ask GHC! Illustrated Haskell <http://illustratedhaskell.org>
  6. 6. Writing fst3 in TH So we already have an Exp, how about those x_1?LamE [TupP [VarP x_1,WildP,WildP]] (VarE x_1)> :t (VarP, VarE)(VarP, VarE) :: (Name -> Pat, Name -> Exp) So, VarP and VarE takes a Name. Let’s see how we can satisfy them:> :t newNamenewName :: String -> Q Name A ha! So we can just plug it into the expression GHC gave us:fst3 = do x <- newName "x" LamE [TupP [VarP x,WildP,WildP]] (VarE x) Illustrated Haskell <http://illustratedhaskell.org>
  7. 7. Evolving fst3 into fstN The following corresponds to the expression (x,_,_) -> xfst3 = do x <- newName "x" LamE [TupP [VarP x,WildP,WildP]] (VarE x) Not surprisingly, to make fst4, we just need to make 3 WildP:fst4 = do x <- newName "x" LamE [TupP [VarP x,WildP,WildP,WildP]] (VarE x) And we can easily generalize it into fstNfstN n = do x <- newName "x" LamE [TupP (VarP x : replicate (n-1) WildP)] (VarE x) Illustrated Haskell <http://illustratedhaskell.org>
  8. 8. Using fstN For technical reasons, splices must be defined in a separate module. So we need to create a new module to use the splice we defined:-- TestFstN.hsmain = print $ $(fstN 3) ("hello world", 1, 3) Illustrated Haskell <http://illustratedhaskell.org>
  9. 9. Quasi Quotes
  10. 10. Quasi Quotes The [| … |] notation that you just used is the quasi quotes for Haskell expression. The contents within quasi quotes will be parsed at compile time. Example: in Data.Array.Repa.Stencil, you could define a stencil like this[stencil2| 0 1 0 1 0 1 0 1 0 |] It is converted to:makeStencil2 (Z:.3:.3) (ix -> case ix of Z :. -1 :. 0 -> Just 1 Z :. 0 :. -1 -> Just 1 Z :. 0 :. 1 -> Just 1 Z :. 1 :. 0 -> Just 1 _ -> Nothing) Illustrated Haskell <http://illustratedhaskell.org>
  11. 11. Quasi Quotes When you do [| x -> x |], the string inside the brackets is parsed by the Haskell compiler and gives you back the AST (Abstract Syntax Tree) Illustrated Haskell <http://illustratedhaskell.org>
  12. 12. Let’s do a simple example We will build a structure to represent HTML documents For simplicity, we omit attributes, self closing tags, etc.-- HTML.hs{-# LANGUAGE TemplateHaskell, QuasiQuotes #-}module HTML wheredata Node = Tag String [Node] -- tag name, children | Text String deriving Show Our target is to use quasi quotes to build a document tree:-- HTMLTest.hsimport HTMLdoc :: Nodedoc = [html|<html>Hello, <strong>TH</strong> world!</html>] -- Node "html" [Text "Hello, ”, Tag "strong" [Text "TH"], Text " world!"] Illustrated Haskell <http://illustratedhaskell.org>
  13. 13. First, a simple HTML parser We’ll sidetrack a bit and make a dead simple HTML parser using Parsec Our focus here isn’t Parsec so we can just skim over this function that does the right thing-- HTML.hstextNode :: Parser NodetextNode = fmap Text $ many1 $ satisfy (/=<)tagNode :: Parser NodetagNode = do tagName <- char < *> many1 letter <* char > children <- many $ try tagNode <|> textNode string "</" >> string tagName >> char > return $ Tag tagName children Illustrated Haskell <http://illustratedhaskell.org>
  14. 14. A simple test for our parser$ ghci HTML.hs> parseTest tagNode "<html>Hello, <strong>TH</strong> world!</html>"Tag "html" [Text "Hello, ",Tag "strong" [Text "TH"],Text " world!”] It works! Illustrated Haskell <http://illustratedhaskell.org>
  15. 15. Now we can write our QuasiQuoter-- HTML.hs  The QuasiQuoter takes 4Html :: QuasiQuoter parameters. Each will be called when the quasi quoteHtml = QuasiQuoter is being invoked to create: htmlExpr  An expression undefined  foo = [html| ... |]  A pattern (for pattern undefined matching) undefined  bar [html| ... |] = 3  A type  A top-level declarationhtmlExpr :: String -> Q ExphtmlExpr = undefined  We will do expression and pattern in this example  For more information consult GHC’s documentation Illustrated Haskell <http://illustratedhaskell.org>
  16. 16.  htmlExpr is supposed to parse the contents within [html| … |] and give back an ExphtmlExpr :: String -> Q ExphtmlExpr str = do filename <- loc_filename `fmap` location case parse tagNode filename str of Left err -> undefined Right tag -> [| tag |] As easy as that, loc_filename and location will give us the filename of the user. Illustrated Haskell <http://illustratedhaskell.org>
  17. 17. Let’s compile it!$ ghc HTML.hsError: No instance for (Lift Node) arising fromarising of `tag’… What is that? Well maybe we can satisfy it by implementing the Lift instance for Node, as instructed:instance Lift Node where lift (Text t) = [| Text t |] lift (Tag name children) = [| Tag name children |] Illustrated Haskell <http://illustratedhaskell.org>
  18. 18. Let’s try it out-- HTMLTest.hs{-# LANGUAGE TemplateHaskell , QuasiQuotes #-}import HTMLmain = print [html|<html>Hello, <strong>TH</strong>world!</html>|]$ ghci HTMLTest.hs> mainTag "html" [Text "Hello, ",Tag "strong" [Text "TH"],Text" world!"] It works! Illustrated Haskell <http://illustratedhaskell.org>
  19. 19. Quasi quoting for patterns Now let’s try to do some operations on our HTML structure In this example we will convert an HTML tree into Markdown Markdown is a simple wiki syntax Example Markdown:Let’s **rock** and _roll_! Corresponding HTML:<html>Lets <strong>rock</strong> and <em>roll</em></html> Usually people convert Markdown to HTML. We will do it the other way here. Illustrated Haskell <http://illustratedhaskell.org>
  20. 20. Let’s make a simple converter-- HTMLTest.hsmarkdown (Tag "strong" children) = "**" ++ concatMap markdown children ++ "**"markdown (Tag "em" children) = "_" ++ concatMap markdown children ++ "_"markdown (Tag _ children) = concatMap markdown childrenmarkdown (Text t) = t That’s some normal Haskell. For fun, we’re going to turn it into:-- HTMLTest.hsmarkdown [html|<strong>|] = "**" ++ concatMap markdown children ++ "**"markdown [html|<em>|] = "_" ++ concatMap markdown children ++ "_"markdown [html|<_>|] = concatMap markdown childrenmarkdown [html|#text|] = text Are we gaining anything? Honestly not much. But we’ll do it for the sake of an TH example. Illustrated Haskell <http://illustratedhaskell.org>
  21. 21. Add a pattern parser to our QuasiQuoter -- HTML.hs html :: QuasiQuoter html = QuasiQuoter htmlExpr htmlPat undefined undefined htmlPat :: String -> Q Pat htmlPat "<_>" = [p| Tag _ children |] htmlPat "#text" = [p| Text text |] htmlPat (<:rest) = undefined -- ...Illustrated Haskell <http://illustratedhaskell.org>
  22. 22. Asking GHC again… Now how do we write the “rest” case? Let’s ask GHC> runQ [p| Tag "strong" chlidren |]ConP HTML.Tag [ LitP (StringL "strong") , VarP chlidren] So there we have almost had it. We just need to use Name at appropriate places and follow the types:htmlPat (<:rest) = return $ ConP (mkName "HTML.Tag”) [ LitP (StringL (init rest)) , VarP (mkName "children")] Illustrated Haskell <http://illustratedhaskell.org>
  23. 23. Some explanationshtmlPat (<:rest) = return $ ConP (mkName "HTML.Tag”) [ LitP (StringL (init rest)) , VarP (mkName "children")] Here we see mkName intead of newName mkName "foo" will translate into an identifier "foo" literally mkName "foo" will become something like "foo_1". You’ll use this when you want to avoid name collisions Illustrated Haskell <http://illustratedhaskell.org>
  24. 24. Let’s test it out!-- HTMLTest.hs{-# LANGUAGE TemplateHaskell , QuasiQuotes #-}import HTMLdoc = [html|<html>Hello, <strong>TH</strong> world!</html>|]markdown [html|<_>|] = concatMap markdown childrenmarkdown [html|#text|] = textmarkdown [html|<strong>|] = "**" ++ concatMap markdown children ++ "**”main = print . markdown $ doc $ runhaskell HTMLTest.hs "Hello, **TH** world!" Illustrated Haskell <http://illustratedhaskell.org>
  25. 25. Summary Use runQ to have GHC write the splice for you Then just fix it up by following the type Illustrated Haskell <http://illustratedhaskell.org>
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×