EECS 700 Functional Programming

Transcription

1 EECS 700 Functional Programming Dr. Andy Gill University of Kansas March 30, / 38

2 Jolt Awards Books (Technical) High Performance MySQL by Baron Schwartz, Peter Zaitsev, Vadim Tkachenko, Jeremy Zawodny, Arjen Lentz, Derek J. Balling (O Reilly Media) Java Power Tools by John Ferguson Smart (O Reilly Media) Programming in Scala by Martin Odersky, Lex Spoon, and Bill Venners (Artima Press) Real World Haskell by John Goerzen, Bryan O Sullivan, Donald Bruce Stewart (O Reilly Media) The iphone Developer s Cookbook: Building Applications with the iphone SDK by Erica Sadun (Addison-Wesley Professional) 2 / 38

3 Jolt Awards Books (Technical) High Performance MySQL by Baron Schwartz, Peter Zaitsev, Vadim Tkachenko, Jeremy Zawodny, Arjen Lentz, Derek J. Balling (O Reilly Media) Java Power Tools by John Ferguson Smart (O Reilly Media) Programming in Scala by Martin Odersky, Lex Spoon, and Bill Venners (Artima Press) Real World Haskell by John Goerzen, Bryan O Sullivan, Donald Bruce Stewart (O Reilly Media) The iphone Developer s Cookbook: Building Applications with the iphone SDK by Erica Sadun (Addison-Wesley Professional) 3 / 38

4 Domain Specific Languages Based on slides by Ulf Norell. I ed him asking permission: Ulf, I m teaching an AFP class here at Kansas, and really like the way you ve presented the concept of a DSL. Can I based my slides of your material? He replied: 4 / 38

5 Domain Specific Languages Based on slides by Ulf Norell. I ed him asking permission: Ulf, I m teaching an AFP class here at Kansas, and really like the way you ve presented the concept of a DSL. Can I based my slides of your material? He replied: Du har skickat ett brev till en epostadress som r under avveckling, vnligen se webbsidan nedan eller kontakta mottagaren fr att f rtt adress. Ditt brev har levererats till mottagaren. 5 / 38

6 Domain Specific Languages Based on slides by Ulf Norell. I ed him asking permission: Ulf, I m teaching an AFP class here at Kansas, and really like the way you ve presented the concept of a DSL. Can I based my slides of your material? He replied: Du har skickat ett brev till en epostadress som r under avveckling, vnligen se webbsidan nedan eller kontakta mottagaren fr att f rtt adress. Ditt brev har levererats till mottagaren. You have sent an to an address which is being phased out, please see the webpage below or contact the recipient to get the correct address. Your has been delivered to the recipient. 6 / 38

7 Domain Specific Languages We have seen several DSLs. All are libraries in Haskell. You need to know Haskell to use any Haskell-hosted DSL. 7 / 38

8 Domain Specific Languages - Anatomy User-code, written in the DSL are centered round a specific type (or types). There are ways of constructing this type, composing this type, running (or making observations about) this type. 8 / 38

9 Our Property DSL (==) :: (Eq a) => a -> a -> Bool ($) :: (a -> b) -> a -> b (==>) :: (Testable a) => Bool -> a -> Property label :: (Testable a) => String -> a -> Property classify :: (Testable a) => Bool -> String -> a -> Property forall :: (Show a, Testable b) => Gen a -> (a -> b) -> Property collect :: (Show a, Testable b) => a -> b -> Property collect a b = label (show a) b test :: (Testable a) => a -> IO () 9 / 38

10 Primitive vs Derived A primitive operation is defined exploiting the definitions of the involved types. A derived operation can be defined purely in terms of other operations. -- Primitive label :: (Testable a) => String -> a -> Property -- derivied collect :: (Show a, Testable b) => a -> b -> Property collect a b = label (show a) b 10 / 38

11 What to think about Compositionally Combining elements into more complex ones should be easy and natural. Abstraction The user shouldn t have to know (or be allowed to exploit) the underlying implementation of your types. (or changing implementation shouldn t break user code!) 11 / 38

12 Implementation of a DSEL Shallow embedding Represent elements by their semantics (what observations they support) Constructor functions and combinators do most of the work run function(s) are (almost) for free Deep embedding Represent elements by how they are constructed Most of the work done by the run function(s) Constructor functions and combinators for free Optimization opportunities (more later) 12 / 38

13 -- our principal type, Expr newtype Expr = Expr (Maybe Int) 13 / 38

14 -- our principal type, Expr newtype Expr = Expr (Maybe Int) -- our way of constructing Expr s lit :: Int -> Expr lit n = Expr (Just n) 14 / 38

15 -- our principal type, Expr newtype Expr = Expr (Maybe Int) -- our way of constructing Expr s lit :: Int -> Expr lit n = Expr (Just n) -- our way of composing Expr s plus :: Expr -> Expr -> Expr plus (Expr (Just v1)) (Expr (Just v2)) = Expr (Just (v1 + v2)) plus = Expr Nothing 15 / 38

16 -- our principal type, Expr newtype Expr = Expr (Maybe Int) -- our way of constructing Expr s lit :: Int -> Expr lit n = Expr (Just n) -- our way of composing Expr s plus :: Expr -> Expr -> Expr plus (Expr (Just v1)) (Expr (Just v2)) = Expr (Just (v1 + v2)) plus = Expr Nothing -- our way of running Expr s runexpr :: Expr -> Maybe Int runexpr (Expr v) = v 16 / 38

17 divide :: Expr -> Expr -> Expr divide (Expr (Just v1)) (Expr (Just v2)) v2 /= 0 = Expr (Just (v1 div v2)) divide = Expr Nothing *Main> runexpr (lit 1) 17 / 38

18 divide :: Expr -> Expr -> Expr divide (Expr (Just v1)) (Expr (Just v2)) v2 /= 0 = Expr (Just (v1 div v2)) divide = Expr Nothing *Main> runexpr (lit 1) Just 1 *Main> runexpr (lit 1 plus lit 2) 18 / 38

19 divide :: Expr -> Expr -> Expr divide (Expr (Just v1)) (Expr (Just v2)) v2 /= 0 = Expr (Just (v1 div v2)) divide = Expr Nothing *Main> runexpr (lit 1) Just 1 *Main> runexpr (lit 1 plus lit 2) Just 3 *Main> runexpr (lit 1 divide lit 2) 19 / 38

20 divide :: Expr -> Expr -> Expr divide (Expr (Just v1)) (Expr (Just v2)) v2 /= 0 = Expr (Just (v1 div v2)) divide = Expr Nothing *Main> runexpr (lit 1) Just 1 *Main> runexpr (lit 1 plus lit 2) Just 3 *Main> runexpr (lit 1 divide lit 2) Just 0 *Main> runexpr (lit 1 divide lit 0) 20 / 38

21 divide :: Expr -> Expr -> Expr divide (Expr (Just v1)) (Expr (Just v2)) v2 /= 0 = Expr (Just (v1 div v2)) divide = Expr Nothing *Main> runexpr (lit 1) Just 1 *Main> runexpr (lit 1 plus lit 2) Just 3 *Main> runexpr (lit 1 divide lit 2) Just 0 *Main> runexpr (lit 1 divide lit 0) Nothing 21 / 38

22 This is an API, implementation can be hidden. -- our principal type, Expr newtype Expr = / 38

23 This is an API, implementation can be hidden. -- our principal type, Expr newtype Expr = our way of constructing Expr s lit :: Int -> Expr 23 / 38

24 This is an API, implementation can be hidden. -- our principal type, Expr newtype Expr = our way of constructing Expr s lit :: Int -> Expr -- our way of composing Expr s plus :: Expr -> Expr -> Expr divide :: Expr -> Expr -> Expr 24 / 38

25 This is an API, implementation can be hidden. -- our principal type, Expr newtype Expr = our way of constructing Expr s lit :: Int -> Expr -- our way of composing Expr s plus :: Expr -> Expr -> Expr divide :: Expr -> Expr -> Expr -- our way of running Expr s runexpr :: Expr -> Maybe Int 25 / 38

26 Deep Embedding -- our principal type, Expr data Expr = Lit Int Plus Expr Expr Divide Expr Expr 26 / 38

27 Deep Embedding -- our principal type, Expr data Expr = Lit Int Plus Expr Expr Divide Expr Expr -- our way of constructing Expr s lit :: Int -> Expr lit n = Lit n 27 / 38

28 Deep Embedding -- our principal type, Expr data Expr = Lit Int Plus Expr Expr Divide Expr Expr -- our way of constructing Expr s lit :: Int -> Expr lit n = Lit n -- our way of composing Expr s plus :: Expr -> Expr -> Expr plus e1 e2 = Plus e1 e2 divide :: Expr -> Expr -> Expr divide e1 e2 = Divide e1 e2 28 / 38

29 runexpr :: Expr -> Maybe Int runexpr (Lit i) = Just i runexpr (Plus e1 e2) = case runexpr e1 of Nothing -> Nothing Just v1 -> case runexpr e2 of Nothing -> Nothing Just v2 -> Just (v1 + v2) runexpr (Divide e1 e2) = case runexpr e1 of Nothing -> Nothing Just v1 -> case runexpr e2 of Nothing -> Nothing Just v2 v2 == 0 -> Nothing otherwise -> Just (v1 div v2) 29 / 38

30 Implementation of a DSEL Shallow embedding Represent elements by their semantics (what observations they support) Constructor functions and combinators do most of the work run function(s) are (almost) for free Deep embedding Represent elements by how they are constructed Most of the work done by the run function(s) Constructor functions and combinators for free Optimization opportunities (more later) 30 / 38

31 A Language for Shapes Step 1: Design the interface (or API) data Shape -- Constructor functions empty :: Shape circle :: Shape -- unit circle square :: Shape -- unit square -- Combinators translate :: Vec -> Shape -> Shape scale :: Vec -> Shape -> Shape rotate :: Angle -> Shape -> Shape union :: Shape -> Shape -> Shape intersect :: Shape -> Shape -> Shape difference :: Shape -> Shape -> Shape -- Run functions inside :: Point -> Shape -> Bool 31 / 38

32 Interface, continued Think about primitive/derived operations No obvious derived operations Sometimes introducing additional primitives makes the language nicer invert :: Shape -> Shape transform :: Matrix -> Shape -> Shape scale :: Vec -> Shape -> Shape scale v = transform (matrix (vecx v) 0 0 (vecy v)) rotate :: Angle -> Shape -> Shape rotate a = transform (matrix (cos a) (-sin a) (sin a) (cos a)) difference :: Shape -> Shape -> Shape difference a b = a intersect invert b 32 / 38

33 Shallow embedding What are the observations we can make of a shape? inside :: Point -> Shape -> Bool So, lets go for newtype Shape = Shape (Point -> Bool) inside :: Point -> Shape -> Bool inside p (Shape f) = f p In general, its not this easy. In most cases you need to generalize the type of the internal function a little to get a compositional shallow embedding. 33 / 38

34 Shallow embedding, continued If we picked the right implementation the operations should now be easy to implement. empty = Shape $ \p -> False circle = Shape $ \p -> ptx p ^ 2 + pty p ^ 2 <= 1 square = Shape $ \p -> abs (ptx p) <= 1 && abs (pty p) <= 1 transform m a = Shape $ \p -> mulpt (inv m) p inside a translate v a = Shape $ \p -> subtract p v inside a union a b = Shape $ \p -> inside p a inside p b intersect a b = Shape $ \p -> inside p a && inside p b invert a = Shape $ \p -> not (inside p a) 34 / 38

35 Deep embedding Representation is easy, just make a datatype of the primitive operations. data Shape = Empty Circle Square Translate Vec Shape Transform Matrix Shape Union Shape Shape Intersect Shape Shape Invert Shape empty circle translate transform union intersect invert = Empty = Circle = Translate = Transform = Union = Intersect = Invert 35 / 38

36 Deep embedding, continued All the work happens in the run function. inside :: Point -> Shape -> Bool p inside Empty = False p inside Circle = ptx p ^ 2 + pty p ^ 2 <= 1 p inside Square = abs (ptx p) <= 1 && abs (pty p) <= p inside Translate v a = subtract p v inside a p inside Transform m a = mulpt (inv m) p inside a p inside Union a b = inside p a inside p b p inside Intersect a b = inside p a && inside p b p inside Invert a = not (inside p a) 36 / 38

37 Example DSL: Chalkboard... $ fmap (choose green white) $ rotate 0.05 $ scale 50 $ checker 37 / 38

38 Example DSL: Chalkboard... $ stack $ [ fmap (choose (withalpha 0.8 col) (transparent white)) $ functionline (\ x -> (x * 400,t + 80 * x * sin (x * t))) 3 count (col,t) <- zip [red,green,blue] [16,18,20] ] ++ [ fmap (choose (withalpha 0.8 col) (transparent white)) $ functionline (\ x -> (400 - x * 400,t - 80 * x * sin (x * t))) 3 count (col,t) <- zip [cyan,purple,yellow] [15,17,20] ] ++ [ pure (alpha white) ] 38 / 38