PFI セミナーで Template Haskell の機能 と Haskell での総称プログラミングの手法を解説したスライド。 スライド中で使用したサンプルはこちらに： http://github.com/konn/Meta-Programming-in-Haskell-Example

1. Metaprogramming
in Haskell

2. Table of Contents
Template Haskell
Generic Programming in Haskell
(Type-level Programming)

3. Table of Contents
Template Haskell
Generic Programming in Haskell
(Type-level Programming)

4. Template Haskell

5. Template Haskell
Haskell

6. Template Haskell
Haskell
C

7. HOC - Haskell Objective-C binding
Class/Instance
jmacro
JavaScript
HAppS
lambdabot
IRC Bot (IRC )

8. TH

9. TH

10. TH
IO

11. TH
IO
( reify )

12. TH
IO
( reify )
DSL

13. TH

14. TH
( )

15. TH
( )
Template Haskell

16. TH
( )
Template Haskell
Q
IO

17. TH
( )
Template Haskell
Q
IO
compile-time wxWidgets, Socket, etc...

18. TH Features
{-# LANGUAGE TemplateHaskell, QuasiQuotes #-}
import Language.Haskell.TH
splice
reify / runIO

19. DEMO

20. 2 RandomDef.hs

21. 2 RandomDef.hs
{-# LANGUAGE TemplateHaskell #-}
module Main where
import Language.Haskell.TH
import System.Random
$( do rnd ← runIO $ randomRIO (0,1)
let nm = mkName (["a", "b"] !! rnd)
m ← [d| main = $(varE $ mkName "a") |]
t ← valD (varP nm) (normalB [| putStrLn " `) " |]) []
(´
return (t:m)
)

22. (RandomDef.hs)
{-# LANGUAGE TemplateHaskell #-}
module Main where
import Language.Haskell.TH
import System.Random
$( do rnd ← runIO $ randomRIO (0,1)
let nm = mkName (["a", "b"] !! rnd)
m ← [d| main = $(varE $ mkName "a") |]
t ← valD (varP nm) (normalB [| putStrLn " `) " |]) []
(´
return (t:m)
)

24. Template Haskell

25. Template Haskell
Exp Dec Pat Type

26. Template Haskell
Exp Dec Pat Type
……(cf. HOC)

27. Template Haskell
Exp Dec Pat Type
……(cf. HOC)
Q

28. putStrLn “Hello!”
= AppE (VarE ‘putStrLn) (LitE (stringL “Hello!”))
main :: IO ()
main = getLine >>= putStrLn
[ SigD (mkName "main") (AppT (VarT ''IO) (VarT ''())), FunD (mkName
"main") [Clause [] (NormalB $ InfixE (Just $ VarE 'getLine) (VarE
'(>>=)) (Just $ VarE 'putStrLn) ) []]]

29. lib2 =
let
l=LetS[ValD(VarP $ mkName"it")(NormalB(f"be"))[]]
f=VarE . mkName
in
DoE [ l, l, l, NoBindS $ f"oh",l,
NoBindS $ InfixE(Just$ f"speaking")(f"words")(Just $ f "wisdom"),l]

30. lib2 =
let
l=LetS[ValD(VarP $ mkName"it")(NormalB(f"be"))[]]
f=VarE . mkName
in
DoE [ l, l, l, NoBindS $ f"oh",l,
NoBindS $ InfixE(Just$ f"speaking")(f"words")(Just $ f "wisdom"),l]
do let it = be
let it = be
let it = be
oh
let it = be
speaking `words` wisdom
let it = be

31. k
GHCi
GHCi> runQ [d| data List a = Cons a (List a) | Nil |]
[DataD [] List [PlainTV a_0] [NormalC Cons [(NotStrict,VarT a_0),
(NotStrict,AppT (ConT List) (VarT a_0))],NormalC Nil []] []]

32. [k| |] (“k” )
Q
[e| putStrLn “foo” |] (e )
[d| main = putStrLn “:-)” |]
[t| Maybe String |]
[p| Just 2 |] (GHC HEAD)
( )
`a, ``Maybe ( )

33. {-# LANGUAGE TemplateHaskell #-}
module Main where
import Language.Haskell.TH
import System.Random
$( do rnd ← runIO $ randomRIO (0,1)
let nm = mkName (["a", "b"] !! rnd)
m ← [d| main = $(varE $ mkName "a") |]
t ← valD (varP nm) (normalB [| putStrLn " ( ´ `) " |]) []
return (t:m)
)

34. (RandomDef.hs)
{-# LANGUAGE TemplateHaskell #-}
module Main where
import Language.Haskell.TH
import System.Random
+
$( do rnd ← runIO $ randomRIO (0,1)
let nm = mkName (["a", "b"] !! rnd)
m ← [d| main = $(varE $ mkName "a") |]
t ← valD (varP nm) (normalB [| putStrLn " ( ´ `) " |]) []
return (t:m)
)

35. (Splice)

36. (Splice)
Q

37. (Splice)
Q
$( )

38. (Splice)
Q
$( )

39. (Splice)
Q
$( )
main = $(1 + ‘a) :: $(myType)

40. (Splice)
Q
$( )
main = $(1 + ‘a) :: $(myType)
$() (6.12 )

41. (Splice)
Q
$( )
main = $(1 + ‘a) :: $(myType)
$() (6.12 )
Splice (6.12 )

42. (Splice)
Q
$( )
main = $(1 + ‘a) :: $(myType)
$() (6.12 )
Splice (6.12 )
Splice import

43. (Splice)
Q
$( )
main = $(1 + ‘a) :: $(myType)
$() (6.12 )
Splice (6.12 )
Splice import

44. Q Monad

45. Q Monad

46. Q Monad
IO

47. Q Monad
IO
runIO $ ...

48. Q Monad
IO
runIO $ ...
(reify)

49. Q Monad
IO
runIO $ ...
(reify)
Q

50. Q Monad
IO
runIO $ ...
(reify)
Q
GHCi runQ $ reify ''Maybe

51. IO
{-# LANGUAGE TemplateHaskell #-}
module Main where
import Language.Haskell.THIO Get
import System.Random
$( do rnd ← runIO $ randomRIO (0,1)
let nm = mkName (["a", "b"] !! rnd)
m ← [d| main = $(varE $ mkName "a") |]
t ← valD (varP nm) (normalB [| putStrLn " `) " |]) []
(´
return (t:m)
)

52. {-# LANGUAGE TemplateHaskell #-}
module Main where
import Language.Haskell.TH
import System.Random
$( do rnd ← runIO $ randomRIO (0,1)
let nm = mkName (["a", "b"] !! rnd)
m ← [d| main = $(varE $ mkName "a") |]
t ← valD (varP nm) (normalB [| putStrLn " `) " |]) []
(´
return (t:m)
)

53. reify
compile-time
( )
derive
DEMO

55. LISP

56. LISP
EDSL

57. LISP
EDSL

58. LISP
EDSL
GHC HEAD

59. LISP
EDSL
GHC HEAD
[$ident| ... |]

60. LISP
EDSL
GHC HEAD
[$ident| ... |]
ident QuasiQuoter

61. LISP
EDSL
GHC HEAD
[$ident| ... |]
ident QuasiQuoter
String → ExpQ String → PatQ

62. LISP
EDSL
GHC HEAD
[$ident| ... |]
ident QuasiQuoter
String → ExpQ String → PatQ
Graph JSON

63. mkTweet :: Int → String → JSValue → JSValue
mkTweet tid text = [$json|
{“status”: {
“id”: #int<tid>, “text”: #str<text>
}}
|]
getID :: JSValue → Int
getID [$json| “id”:#Int{var} |] = var

64. mkTweet :: Int → String → JSValue → JSValue
mkTweet tid text = [$json|
{“status”: {
“id”: #int<tid>, “text”: #str<text>
}}
|]
getID :: JSValue → Int
getID [$json| “id”:#Int{var} |] = var
( )

65. mkTweet :: Int → String → JSValue → JSValue
mkTweet tid text = [$json|
{“status”: {
“id”: #int<tid>, “text”: #str<text>
}}
|]
getID :: JSValue → Int
getID [$json| “id”:#Int{var} |] = var
( )

66. JSON
data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord)
-- QuasiQuoter
json :: QuasiQuoter
json = QuasiQuoter quoteJSONExp quoteJSONPat
quoteJSONExp :: String → ExpQ
quoteJSONPat :: String → PatQ
quoteJSONPat src = ...
quoteJSONExp src = ...

67. JSON
data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord)
-- QuasiQuoter
json :: QuasiQuoter
json = QuasiQuoter quoteJSONExp quoteJSONPat
quoteJSONExp :: String → ExpQ
quoteJSONPat :: String → PatQ
quoteJSONPat src = ...
quoteJSONExp src = ...

68. JSON
data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord)
-- QuasiQuoter
json :: QuasiQuoter
json = QuasiQuoter quoteJSONExp quoteJSONPat
quoteJSONExp :: String → ExpQ
quoteJSONPat :: String → PatQ
quoteJSONPat src = ...
quoteJSONExp src = ...

69. JSON
data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord)
-- QuasiQuoter
json :: QuasiQuoter
json = QuasiQuoter quoteJSONExp quoteJSONPat
quoteJSONExp :: String → ExpQ
quoteJSONPat :: String → PatQ
quoteJSONPat src = ...
quoteJSONExp src = ...

72. dataToExpQ, dataToPatQ

73. dataToExpQ, dataToPatQ
jsonPat src= dataToPatQ (const Nothing `extQ` antiQuoteP)
(parseJSON src)
antiQuoteP (Var a) = Just (varP (mkName a))
antiQuoteP _ = Nothing

74. dataToExpQ, dataToPatQ
jsonPat src= dataToPatQ (const Nothing `extQ` antiQuoteP)
(parseJSON src)
antiQuoteP (Var a) = Just (varP (mkName a))
antiQuoteP _ = Nothing

75. data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord, Data, Typeable)
...
parseExpr = ... -- Parser
quoteJSONPat src = do
let exp = parseExpr src
dataToPatQ (const Nothing `extQ` antiStrPat) exp
antiStrPat :: Expr → Maybe PatQ
antiStrPat (Var a) = Just $ varP (mkName a)
antiStrPat _ = Nothing

76. data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord, Data, Typeable)
...
parseExpr = ... -- Parser
quoteJSONPat src = do
let exp = parseExpr src
dataToPatQ (const Nothing `extQ` antiStrPat) exp
antiStrPat :: Expr → Maybe PatQ
antiStrPat (Var a) = Just $ varP (mkName a)
antiStrPat _ = Nothing

77. data JSON = JSNumber Int | JSString String
| ...
| Var String
deriving (Show, Eq, Ord, Data, Typeable)
...
parseExpr = ... -- Parser
quoteJSONPat src = do
let exp = parseExpr src
dataToPatQ (const Nothing `extQ` antiStrPat) exp
antiStrPat :: Expr → Maybe PatQ
antiStrPat (Var a) = Just $ varP (mkName a)
antiStrPat _ = Nothing
Var

78. ……
dataToExpQ extQ
…… ……

79. Generic Programming in Haskell
Template Haskell
Generic Programming in Haskell
(Type-level Programming)

80. Haskell

81. Haskell
——Wikipedia

82. Haskell
——Wikipedia
=

83. Haskell
——Wikipedia
=

84. Haskell
——Wikipedia
=

86. Generic Programming
in Haskell
(Generics ; GHC )
SYB (Scrap Your Boilerplate)
Instant Generics

87. Generic Programming
in Haskell
(Generics ; GHC )
SYB (Scrap Your Boilerplate)
Instant Generics

90. Sum of Product

91. Sum of Product
( )

92. Sum of Product
( )

93. Sum of Product
( )
{-# LANGUAGE Generics, TypeOperators #-}

94. Sum of Product
( )
{-# LANGUAGE Generics, TypeOperators #-}
import GHC.Generics

95. data Bool = False | True
= Unit :+: Unit
data Maybe a = Nothing | Just a
= Unit :+: a
Just 12 = Inr 12, Nothing = Inl Unit
data List a = Nil | Cons a (List a)
= Unit :+: (a :*: (List a))
[1,2,3] = Inr (1 :*: Inr (2 :*:
Inr (3 :*: Inl Unit)))

96. Binary Encode
class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
toBin {| Unit |} Unit = [0]
toBin {| p :*: q |} (a :*: b) = toBin a ++ toBin b
toBin {| p :+: q |} (Inl a) = 0:toBin a
toBin {| p :+: q |} (Inr b) = 1:toBin b
fromBin {| Unit |} (0:xs) = (Unit, xs)
fromBin {| p :*: q |} bin =
let (a, bin') = fromBin bin
(b, bin'') = fromBin bin'
...

97. class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
toBin {| Unit |} Unit = [0]
toBin {| p :*: q |} (a :*: b) = toBin a ++ toBin b
toBin {| p :+: q |} (Inl a) = 0:toBin a
toBin {| p :+: q |} (Inr b) = 1:toBin b
fromBin {| Unit |} (0:xs) = (Unit, xs)
fromBin {| p :*: q |} bin =
let (a, bin') = fromBin bin
(b, bin'') = fromBin bin'
in ...

98. class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
toBin {| Unit |} Unit = [0]
toBin {| p :*: q |} (a :*: b) = toBin a ++ toBin b
toBin {| p :+: q |} (Inl a) = 0:toBin a
toBin {| p :+: q |} (Inr b) = 1:toBin b
fromBin {| Unit |} (0:xs) = (Unit, xs)
fromBin {| p :*: q |} bin =
let (a, bin') = fromBin bin
(b, bin'') = fromBin bin' in (a :*: b, bin’’)
...

99. ( Int, Char) instance
instance Bin Int where
toBin = ....
instance Bin Char where
toBin = ...
instance Bin a Bin [a]
instance (Bin a, Bin b) Bin (a, b)
instance Bin a Bin (Maybe a)
instance (Bin a, Bin b) Bin (Either a b)

100. DEMO

101. default method
a [a] Maybe a

102. Generic Programming
in Haskell
(Generics ; GHC )
SYB (Scrap Your Boilerplate)
Instant Generics

103. Scrap Your Boilerplate
syb
Haskell
dataToExpQ

104. Typeable / Data

105. Typeable / Data
Typeable:
cast ( )

106. Typeable / Data
Typeable:
cast ( )
Data: (gfoldl)
cast

107. Typeable / Data
GHC
{-# LANGUAGE DeriveDataTypeable #-}
data Tree a = Leaf a | Branch (Tree a) (Tree a)
deriving (Data, Typeable)
Standalone deriving
{-# LANGUAGE StandaloneDeriving #-}
deriving instance Typeable1 Tree
deriving instance Data a Data (Tree a)

108. --
data Expr = Num Int
| Var String
| Plus Expr Expr
| Minus Expr Expr
| Multi Expr Expr
| Div Expr Expr
deriving (Show, Eq, Data, Typeable)
normalize :: Expr → Expr
normalize = everywhere (mkT normalize')
normalize' (Plus (Num n) (Num m)) = Num (n + m)
normalize' (Multi (Num n) (Num m)) = Num (n * m)
normalize' (Minus (Num n) (Num m)) = Num (n - m)
normalize' (Div (Num n) (Num m)) = Num (n `div` m)
normalize' x =x

109. SYB

110. SYB

111. SYB

112. SYB

113. SYB
mkT :: (b → b) → (a → a)

114. SYB
mkT :: (b → b) → (a → a)

115. SYB
mkT :: (b → b) → (a → a)
everywhere :: GenericT → GenericT

116. SYB
mkT :: (b → b) → (a → a)
everywhere :: GenericT → GenericT
bottom-up

117. SYB
mkT :: (b → b) → (a → a)
everywhere :: GenericT → GenericT
bottom-up
top-down everywhere'

118. (1)
GenericT = ∀a. a → a
Transformer
mkT fun
trans `extT` fun
GenericM = ∀a. a → m a :
GenericQ = ∀a. a → r
Query
( ) `mkQ` fun
query `extQ` fun

119. (2)
GenericB = ∀a. a
Builder
builder `extB` fun
GenericR = ∀a. m a
Reader
mkR fun
reader `extR` fun

120. gmapT :: GenericT → a → a
somewhere :: GenericM m → GenecirM m
everything :: (r → r → r) → GenericQ r → GenericQ r
listify :: (r → Bool) → GenericQ [r]
gsize/glength :: GenericQ Int

121. dataToExpQ
dataToExpQ
:: Data a GenericQ (Maybe ExpQ)
→ a → ExpQ
(const Nohting `ext` anti)

122. SYB

123. SYB

124. SYB
cast

125. Generic Programming
in Haskell
(Generics ; GHC )
SYB (Scrap Your Boilerplate)
Instant Generics

126. Instant Generics

127. Instant Generics
(Type families)
DPH (Data Parallel Haskell)

130. Generics

131. Generics

132. Generics

133. Generics

134. IG
Representable a
type Rep a
data U = U
data a :+: b = L a | R b ( )
data a :*: b = a :*: b
data C con a = C a
data Var p = Var p
data Rec p = Rec p

135. Int, Bool Int, Bool
data Maybe a = Nothing | Just a
type Rep (Maybe a)
= C Maybe_Nothing_ U
:+: C Maybe_Just_ (Var a)
Just 12 = R(C(Var 12)), Nothing = L(C U)

136. Int, Bool Int, Bool
data Maybe a = Nothing | Just a
type Rep (Maybe a)
= C Maybe_Nothing_ U
:+: C Maybe_Just_ (Var a)
Just 12 = R(C(Var 12)), Nothing = L(C U)

137. 1 Binary Encode
class Bin a where
toBin :: a → [Int]
fromBin :: [Int] → (a, [Int])
C, Var, Rec
instance Bin U where
toBin U = []
fromBin xs = (U, [])
instance (Bin a, Bin b) Bin (a :+: b) where
toBin (L a) = 0:toBin a
toBin (R b) = 1:toBin b
fromBin (0:bin) = ...
...
instance (Bin a, Bin b) Bin (a :*: b) where
toBin (a :*: b) = toBin a ++ toBin b
fromBin bin = ...
instance Bin Int where
...

138. def_toBin :: (Representable a, Bin (Rep a))
a → [Int]
def_toBin = toBin . from
...
instance Bin a Bin [a] where
toBin = def_toBin; fromBin = def_fromBin

139. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)

140. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)

141. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)

142. 2
! class Normalize a where
normalize :: a → a
instance Normalize U
instance Normalize (Var a)
...
instance Normalize a Normalize (Rec a) where
normalize (Rec a) = Rec (normalize a)

143. Expr
dft_normalize
:: (Representable a, Normalize (Rep a)) a→a
dft_normalize = to . normalize . from
instance Normalize Expr where
normalize x = case dft_normalize x of
Plus (Num n) (Num m) → Num (n + m)
Multi (Num n) (Num m) → Num (n * m)
Minus (Num n) (Num m) → Num (n - m)
Div (Num n) (Num m) → Num (n `div` m)
x →x
Var Int, Char

144. Instant Generics

145. Instant Generics

146. Instant Generics

147. 100000(ms)
10000(ms)
1000(ms)
100(ms)
10(ms)
1(ms)
geq rmWeights selectInt selectIntAcc
SYB Instant Generics

148. 100000(ms)
10000(ms)
1000(ms)
100(ms)
10(ms)
1(ms)
geq rmWeights selectInt selectIntAcc
SYB Instant Generics

149. 100000(ms)
10000(ms)
1000(ms)
100(ms)
10(ms)
1(ms)
geq rmWeights selectInt selectIntAcc
SYB Instant Generics

150. 100000(ms)
10000(ms)
1000(ms)
100(ms)
10(ms)
1(ms)
geq rmWeights selectInt selectIntAcc
SYB Instant Generics

151. 100000(ms)
75000(ms)
50000(ms)
25000(ms)
0(ms)
geq rmWeights selectInt selectIntAcc
SYB Instant Generics

152. SYB

153. Generics
SYB
IG

154. GP
SYB with class
Data
Smash
( )
SYB
Uniplate
MPTC

155. Questions?