10 Combining Deep and Shallow DSL Embedding

Size: px

Start display at page:

Download "10 Combining Deep and Shallow DSL Embedding"

Ethan Waters
6 years ago
Views:

1 10 Combining Deep and Shallow DSL Embedding Have your cake and eat it too 1

2 data Cmd = Line Point Point Tri Point Int Int Circle Point Int Seq Cmd Cmd sem :: Cmd Pic sem (Line p1 p2) = Line p1 p2 sem (Circle p r) = Circle p r Deep vs. Shallow DSLs Abstract Syntax Semantic Domain type Point = (Int,Int) data Pic = Line Point Point sem (Tri p@(x,y) w h) = Line p (x,y+h) :+: Line p (x+w,h) :+: Line (x,y+h) (x+w,y) sem (Seq c c ) = sem c :+: sem c Semantic Function Circle Point Int Pic :+: Pic Semantic Domain type Point = (Int,Int) data Pic = Line Point Point Circle Point Int Pic :+: Pic triangle :: Point Int Int Pic triangle p@(x,y) w h = Line p (x,y+h) :+: Line p (x+w,h) :+: Syntax Functions Line (x,y+h) (x+w,y) Deep embedding Shallow embedding 2

3 Shallow vs. Deep Embedding Advantages of deep embeddings Multiple interpretations Enables analyses Enables transformations Advantages of shallow embeddings Simple & fast No redundancy in representation Easy extensibility Indirect manipulation of the domain Direct manipulation of the domain 3

4 Abstract Syntax data Expr = Lit Int Neg Expr Add Expr Expr Deep Embedding eval :: Expr Int Evaluator eval (Lit n) = n eval (Neg e) = -(eval e) eval (Add e1 e2) = eval e1 + eval e2 e1 :: Expr e1 = Add (Lit 8) (Neg (Add (Lit 1) (Lit 2))) eval e1 > 5 Pretty Printer pp :: Expr String pp (Lit n) = show n pp (Neg e) = "(-" ++ pp e ++ ")" pp (Add e1 e2) = "(" ++ pp e1 ++ " + " ++ pp e2 ++ ")" pp e1 > "(8 + (-(1 + 2)))" Two interpreters 4

5 Semantic Domain type D = Int lit :: Int D lit n = n Shallow Embedding e1 :: Expr e1 = Add (Lit 8) (Neg (Add (Lit 1) (Lit 2))) data Expr = Lit Int Neg Expr eval e1 Add Expr Expr > 5 pp e1 > "(8 + (-(1 + 2)))" neg :: D D neg e = - e d1 :: D d1 = add (lit 8) (neg (add (lit 1) (lit 2))) add :: D D D add e1 e2 = e1 + e2 Syntax Functions d1 > 5 pp d1??? How to pretty-print shallow expressions? 5

Generic Domain class Exp d where lit :: Int d neg :: d d add :: d d d Final Embedding instance Exp Int where lit n = n neg e = - e add e1 e2 = e1 + e2 eval :: Int Int eval = id Evaluator f1 :: Exp d

6 Generic Domain class Exp d where lit :: Int d neg :: d d add :: d d d Final Embedding instance Exp Int where lit n = n neg e = - e add e1 e2 = e1 + e2 eval :: Int Int eval = id Evaluator f1 :: Exp d => d f1 = add (lit 8) (neg (add (lit 1) (lit 2))) Generic value instance Exp String where lit n = show n neg e = "(-" ++ e ++ ")" eval f1 add e1 e2 = "(" ++ e1 ++ " + " ++ e2 ++ ")" > 5 pp :: String String Select Int instance pp f1 > "(8 + (-(1 + 2)))" pp = id Pretty Printer 6

7 module E where The Expression Problem module O where import E optimize :: Expr Expr optimize = Adding operations is easy data Expr = Lit Int Neg Expr Add Expr Expr module M where In OO: Adding operations is hard Adding data variants is easy import qualified E X data Expr is E.Expr extended by Mul Expr Expr X eval is E.eval extended by eval (Mul e1 e2) = eval e1 * eval e2 Adding data variants is hard 7

8 module E where The Expression Problem module M where import qualified E data Expr = Lit Int Neg Expr Add Expr Expr data Expr = E E.Expr Mul Expr Expr e2 :: Expr e2 = Mul (E (E.Lit 7)) (E E.e1) e3 ::? Xe3 = E.Neg e2 E.Expr E.Expr Expr E.Expr and Expr are different types 8

module Exp where Extensibility of Final Embeddings class Exp d where import Exp New Domain instance Mul Int where mul e1 e2 = e1 * e2 Evaluator lit :: Int d class Mul d where neg :: d d mul :: d d d

9 module Exp where Extensibility of Final Embeddings class Exp d where import Exp New Domain instance Mul Int where mul e1 e2 = e1 * e2 Evaluator lit :: Int d class Mul d where neg :: d d mul :: d d d instance Mul String where add :: d d d mul e1 e2 = "(" ++ e1 ++ " * " ++ e2 ++ ")" Pretty Printer f1 :: Exp d => d f1 = add (lit 8) (neg (add (lit 1) (lit 2))) f2 :: (Mul d,exp d) => d f2 = add (lit 7) (neg (mul (lit 1) (lit 2))) f3 :: (Mul d,exp d) => d f3 = mul (lit 7) f1 eval f2 > 5 eval f3 > 35 pp f2 > "(7 + (-(1 * 2))) pp f3 Final embedding solves the expression problem > "(7 * (8 + (-(1 + 2))))" 9

10 Non-Compositional Transformations Neg is treated differently depending on context Nested pattern matching e ::= i -e e + e pushneg :: Expr Expr pushneg e@(lit _) pushneg e@(neg (Lit _)) pushneg (Neg (Neg e)) Normalization Negation only at leaves = e = e = pushneg e pushneg (Neg (Add e1 e2)) = Add (pushneg (Neg e1)) (pushneg (Neg e2)) pushneg (Add e1 e2) = Add (pushneg e1) (pushneg e2) e ::= f e + e f ::= n -n e1 = Add (Lit 8) (Neg (Add (Lit 1) (Lit 2))) e1n = pushneg e1 e4n = pushneg (Neg e1) e5n = pushneg (Neg e1n) pp e1n > "(8 + ((-1) + (-2)))" pp e4n "((-8) + (1 + 2))" pp e5n "((-8) + (1 + 2))" 10

11 Non-Compositional Transformations class Exp d where lit :: Int d neg :: d d add :: d d d data Ctx = Pos Neg instance Exp d => Exp (Ctx d) where pushneg :: Expr Expr lit n Pos = lit n pushneg e@(lit _) = e lit n Neg = neg (lit n) pushneg e@(neg (Lit _)) = e neg e Neg = e Pos pushneg (Neg (Neg e)) = pushneg e neg e Pos = e Neg pushneg (Neg (Add e1 e2)) = Add (pushneg (Neg e1)) (pushneg (Neg e2)) add e1 e2 ctx = add (e1 ctx) (e2 ctx) pushneg (Add e1 e2) = Add (pushneg e1) (pushneg e2) pushneg :: (Ctx d) d pushneg e = e Pos 11

12 Non-Compositional Transformations data Ctx = Pos Neg instance Exp d => Exp (Ctx d) where lit n Pos = lit n lit n Neg = neg (lit n) neg e Neg = e Pos neg e Pos = e Neg add e1 e2 ctx = add (e1 ctx) (e2 ctx) - (1 + (-2)) pushneg (neg (add (lit 1) (neg (lit 2)))) = neg (add (lit 1) (neg (lit 2))) Pos = add (lit 1) (neg (lit 2)) Neg = add (lit 1 Neg) (neg (lit 2) Neg) = add (neg (lit 1)) (neg (lit 2) Neg) pushneg :: (Ctx d) d pushneg e = e Pos = add (neg (lit 1)) (lit 2 Pos) = add (neg (lit 1)) (lit 2)

13 Non-Compositional Transformations data Ctx = Pos Neg Ctx d instance Exp d => Exp (Ctx d) where lit n Pos = lit n pushneg (neg (add (lit 1) (neg (lit 2)))) lit n Neg = neg (lit n) = neg (add (lit 1) (neg (lit 2))) Pos neg e Neg = e Pos = add (lit 1) (neg (lit 2)) Neg neg e Pos = e Neg add e1 e2 ctx = add (e1 ctx) (e2 ctx) = add (lit 1 Neg) (neg (lit 2) Neg) = add (neg (lit 1)) (neg (lit 2) Neg) pushneg :: (Ctx d) d pushneg e = e Pos = add (neg (lit 1)) (lit 2 Pos) = add (neg (lit 1)) (lit 2) d 13

Outline. What is semantics? Denotational semantics. Semantics of naming. What is semantics? 2 / 21

Outline. What is semantics? Denotational semantics. Semantics of naming. What is semantics? 2 / 21 Semantics 1 / 21 Outline What is semantics? Denotational semantics Semantics of naming What is semantics? 2 / 21 What is the meaning of a program? Recall: aspects of a language syntax: the structure of