FizzBuzzinHaskell by embeddingadsl

Transcription

1 FizzBuzzinHaskell by embeddingadsl Maciej Piróg Leuven Haskell User Group 24 May 2016

2 Players generally sit in a circle. The player designated to go first says the number 1, and each player thenceforth counts one number in turn. However, any number divisible by three is replaced by the word fizz and any divisible by five by the word buzz. Numbers divisible by both become fizzbuzz. A player who hesitates or makes a mistake is eliminated from the game. (Wikipedia) We solve the problem for a single n. Input: A natural naumber n. Output: fizz, buzz, fizzbuzz, or n.

3 Program A: fizzbuzz :: Int String fizzbuzz n = if n mod 3 == 0 n mod 5 == 0 then "fizzbuzz" else if n mod 3 == 0 then "fizz" else if n mod 5 == 0 then "buzz" else show n modularity information flow = control flow

4 Program B: fizzbuzz :: Int String fizzbuzz n = if n mod 3 == 0 then "fizz" ++ if n mod 5 == 0 then "buzz" else "" else if n mod 5 == 0 then "buzz" else show n modularity information flow = control flow

5 Program C: ( ) :: String String String "" s = s a s = a fizzbuzz :: Int String fizzbuzz n = ( ( if n mod 3 == 0 then "fizz" else "") ++ if n mod 5 == 0 then "buzz" else "") show n modularity information flow = control flow

6 Program D:? modularity information flow = control flow

7 So many ways to write FizzBuzz. Too many, maybe?

8 Dijkstra in A Discipline of Programming introduces an imperative language with only two instructions: Skip an idle instruction, it does nothing at all Halt stops the execution of the program

9 Enter the Skip Halt Print language We extend Dijkstra s language with an additional construct that allows us to print stuff out. For example, the program Print "hello" ; Skip ; Halt ; Print "world" prints out the string hello.

10 We implement Skip Halt Print in Haskell: data Cmd= Skip Halt Print String type Program = [Cmd] interp :: Program String interp (Skip : xs) = interp xs interp (Halt : xs) = "" interp (Print s : xs) = s ++ interp xs interp [ ] = ""

11 NO, we cannot write a program that solves FizzBuzz in SHP, and that is for many reasons (no input, no conditional execution, no operations on numbers). INSTEAD, for each n, we will write an SHP program that solves FizzBuzz for n, and then we interpret this program.

12 We build SHP programs out of one hole contexts, that is, programs with placeholders: Skip ; Print "hello" ; ; Print "world" We can insert a program (say, Print "cruel") into the hole: Skip ; Print "hello" ; Print "cruel" ; Print "world" or compose with another context (say, Skip ; ; Halt): Skip ; Print "hello" ; Skip ; ; Halt; Print "world" We use Higher-Order Abstract Syntax to represent contexts in Haskell!

13 An SHP program that solves FB for a given n: type Context = Program Program fizz, buzz, base :: Int Context fizz n n mod 3 == 0 = λx [Print "fizz" ] ++ x ++ [Halt] otherwise = λx x buzz n n mod 5 == 0 = λx [Print "buzz" ] ++ x ++ [Halt] otherwise = λx x base n = λx x ++ [Print (show n)] fb :: Int Program fb n = (base n fizz n buzz n) [Skip] fizzbuzz :: Int String fizzbuzz n = interp (fb n)

14 For example: fb 1 = [Skip, Print 1 ] fb 3 = [Print "fizz", Skip, Halt, Print 3 ] fb 5 = [Print "buzz", Skip, Halt, Print 5 ] fb 15 = [Print "fizz", Print "buzz", Skip, Halt, Halt, Print 15 ]

15 Let s perform some program calculation...

16 interp is a fold: step :: Cmd String String step Skip xs = xs step Halt xs = "" step (Print s) xs = s ++ xs interp :: Program String interp = foldr step ""

17 Some program calculation: interp [Print "c", Halt, Skip] = foldr step "" [Print "c", Halt, Skip] = foldr ( ) id [step (Print "c"), step Halt, step Skip] "" = foldr ( ) id [("c" ++), const "", id] "" = (("c" ++) (const "") id) ""

18 An SHP program that solves FB for a given n, again: type Context = Program Program fizz, buzz, base :: Int Context fizz n n mod 3 == 0 = λx [Print "fizz" ] ++ x ++ [Halt] otherwise = λx x buzz n n mod 5 == 0 = λx [Print "buzz" ] ++ x ++ [Halt] otherwise = λx x base n = λx x ++ [Print (show n)] fb :: Int Program fb n = (base n fizz n buzz n) [Skip] fizzbuzz :: Int String fizzbuzz n = interp (fb n)

19 It is transformed into: type Program = String String type Context = Program Program fizz, buzz, base :: Int Context fizz n n mod 3 == 0 = λx ("fizz" ++) x (const "") otherwise = id buzz n n mod 5 == 0 = λx ("buzz" ++) x (const "") otherwise = id base n = λx x ++ [Print (show n)] fizzbuzz :: Int String fizzbuzz n = (base n fizz n buzz n) ""

20 Make auxiliary functions local definitions + more inlining: fizzbuzz :: Int String fizzbuzz n = (fizz buzz) id (show n) where fizz n mod 3 == 0 = λx const ("fizz" ++ x "") otherwise = id buzz n mod 5 == 0 = λx const ("buzz" ++ x "") otherwise = id

21 We abstract over fizzing and buzzing: fizzbuzz :: Int String fizzbuzz n = (test 3 "fizz" test 5 "buzz") id (show n) where test d s x n mod d == 0 = const (s ++ x "") otherwise = x type of test? test :: Int String (String String) String String

22 We abstract over fizzing and buzzing: fizzbuzz :: Int String fizzbuzz n = (test 3 "fizz" test 5 "buzz") id (show n) where test d s x v n mod d == 0 = s ++ x "" otherwise = x v type of test? test :: Int String (String String) String String

23 Takeaway FizzBuzz is not simple at all. Meaning, we can have some fun even with such a simple problem. But will I get a job? Higher-order functions are your tool to express advanced control flow. Details in the paper FizzBuzz in Haskell by embedding a domain-specific language. The Monad.Reader 23:7-16, T&Q?

24 THE END