Functioneel Programmeren Daan Leijen. Wat gaan we doen? 3 fundamentele principes van computatie Equationeel redeneren IO-monad GUI's in Haskell (wxHaskell)

Presentatie over: "Functioneel Programmeren Daan Leijen. Wat gaan we doen? 3 fundamentele principes van computatie Equationeel redeneren IO-monad GUI's in Haskell (wxHaskell)"— Transcript van de presentatie:

1 Functioneel Programmeren Daan Leijen

2 Wat gaan we doen? 3 fundamentele principes van computatie Equationeel redeneren IO-monad GUI's in Haskell (wxHaskell) Bouncing balls

3 De 3 principes van computatie Geformuleerd door de wiskundige Leibniz in 1666 in zijn "Dissertatio de arte combinatoria" Leibniz probeerde alle redenaties te reduceren tot een combinatie van basis waarden zoals getallen, letters, geluiden en kleuren. Abstractie Parametrisatie Reductie

4 0. Waarden 32 2*16 twee-en-dertig 4*4 + 4*4 thirty-two …

5 0. Vele soorten waarden 32(getal) 'a'(letter) "hoi"(string) ["hoi","hi"](lijst van strings) length(functies)  (plaatjes (bitmaps)) { } (set van kleuren)

6 0. Waarden Programmeren is niets anders dan een waarde opschrijven…

7 1. Abstractie 4*4 + 4*4 let x = 4*4 in x+x of ook: x + x where x = 4*4

8 2. Reductie We hebben een reductie regel nodig om te "rekenen" Formeel: let x = e 1 in e 2 == e 2 [x  e 1 ] Heet ook: β-reductie of Leibniz-rule

9 2. Reductie Reductie in de praktijk: let x = 4*4 in x+x == { reductie (abstractie) } 4*4 + 4*4 == { wiskunde } 32

10 3. Parametrisatie Definieer 1 functie voor vele waarden: fun :: Int -> Int fun a = let x = a*a in x+x

11 3. Parametrisatie Ook hier geldt reductie fun 4 =={ parametrisatie } let x = 4*4 in x+x =={ abstractie } 4*4 + 4*4 =={ wiskunde } 32

12 Helium Reductie is wel veel werk, dus dat laten we de computer doen…

13 Equationeel redeneren Som van een lijst: sum :: [Int]  Int sum [] = 0 sum (x:xs) = x + sum xs

14 Equationeel redeneren sum [1,2] =={ syntax } sum (1 : (2 : [])) =={ leibniz } 1 + sum (2:[]) =={ leibniz } 1 + (2 + sum []) == { leibniz } 1 + 2 + 0 =={ wiskunde } 3

15 Functies Met de basis principes kun je alleen functies construeren: Voor gegeven parameters altijd hetzelfde resultaat.

16 Vergelijk let x = "hi" in (x ++ x) let x = getLine in (x ++ x) String x = System.In.GetLine(); System.Out.WriteLine(x); (getLine ++ getLine)

17 Side-effects Het gaat mis omdat "getLine" geen functie is. We krijgen steeds andere resultaten. Er bestaan vele van dit soort operaties: "putStr", "random", "showWindow", etc.

18 "do" notatie Met de "do" notatie kunnen we expliciet zijn hoe vaak iets geevalueerd word. do x <- getLine putStr (x ++ x) do x <- getLine y <- getLine putStr (x ++ y)

19 Typering We willen ons eerdere voorbeeld voorkomen. getLine :: IO String putStr :: String -> IO () getLine ++ getLine

20 "do" notatie De "do" notatie pakt IO waardes uit. do x <- getLine putStr (x ++ x) :: IO String :: String :: IO ()

21 Pure waarden Met "return" maken we van een gewone waarde een IO computatie: return :: a -> IO a do x <- getLine return x == getLine

22 Sequence Abstraheren over computaties: sequence :: [IO a] -> IO [a] sequence [] = return [] sequence (io:ios) = do x <- io xs <- sequence ios return (x:xs)

23 Voorbeeld Laat een lijst van strings zien of putStrs :: [String] -> IO [()] putStrs xs = sequence (map putStr xs) putStrs = sequence. map putStr

24 Sequence_ Vergeet het resultaat: sequence_ :: [IO a] -> IO () sequence_ ios = do xs <- sequence ios return ()

25 Ultimate IO: GUI's

26 The perfect GUI library Efficient Portable Native look-and-feel Lots of standard functionality Easy to use

27 wxWidgets Large C++ library for writing GUI's: Portable (Windows, GTK, MacOS X, Symbian, etc) Wrapper around native controls. Free and open source Active developer/user community Dynamic event model

28 AOL communicator

29 Audacity

30 wxHaskell A binding of Haskell and wxWidgets It is huge: 2800 methods 1400 constants 500 classes

31 Demo

32 The technology behind the winners..

33 It is portable

34 Minimal program main = start gui gui :: IO () gui = do frame [text := "hello!"] return () [Prop (Frame ())] -> IO (Frame ())

35 Buttons main = start gui gui :: IO () gui = do f <- frame [text := "Hello!"] q <- button f [text := "Quit"] set f [layout := widget q] Frame a ->[Prop (Button ())]->IO (Button ())

36 Event handlers gui :: IO () gui = do f <- frame [text := "Hello!"] b <- button f [text := "Quit",on command := close f] set f [layout := widget b]

37 Setters set w ps = sequence (map (set1 w) ps) set1 w p = …

38 Layout combinators layout := widget b margin 10 $ floatCenter (widget b) margin 10 $ column 5 [floatCenter(caption "Hello"),floatCenter(widget b)] Layout -> Layout

39 Complex layout

40 Bouncing Balls

41 Representation Iedere bal is gerepresenteerd als een lijst van al zijn toekomstige posities. t0 = [] … t10 = [[(4,8),(4,7),(4,6),…],[(9,1),(9,0),(9,1),(9,2),…]] … t11 = [[(4,7),(4,6),…],[(9,0),(9,1),(9,2),…]]

42 Questions? http://wxhaskell.sf.net http://www.cs.uu.nl/~daan