Exploring Haskell Programming: Functions, Animation, and Music

1. Having Fun with FunctionsHow you can use functions to: write interactive animation, control robots, and compose music. Zhanyong Wan, Yale UniversitySeptember, 2001 Acknowledgement: Part of the slides provided by Paul Hudak

2. Roadmap •  Programming languages research at Yale • Introduction to Haskell • Domain specific languages • FRP • Haskore • Conclusions and video USTC

3. Alan Perlis’ Epigrams in Programming • A programming language is low level when its programs require attention to the irrelevant. • If a listener nods his head when you're explaining your program, wake him up. • Optimization hinders evolution. • Once you understand how to write a program get someone else to write it. • The use of a program to prove the 4-color theorem will not change mathematics - it merely demonstrates that the theorem, a challenge for a century, is probably not important to mathematics. • There are two ways to write error-free programs; only the third one works. • A language that doesn't affect the way you think about programming, is not worth knowing. USTC

4. PL Research at Yale • Faculty members (a partial list): • Paul Hudak: functional programming (Haskell), domain specific languages, language theory. • John Peterson: functional programming (Haskell), domain specific languages, compilation • Zhong Shao: functional programming (ML), type theory, compilation techniques, proof-carrying code. • Carsten Schuermann: logical frameworks, theorem proving, type theory, functional programming. USTC

5. Having Fun at Yale audio • John Peterson • Rock climbing • Skiing • Kayaking • Paul Hudak • Music • Soccer coaching • Skiing • Rock climbing • Kayaking USTC

6. Roadmap • Programming languages research at Yale •  Introduction to Haskell • Domain specific languages • FRP • Haskore • Conclusions and video USTC

7. Haskell by Examples • Higher-order functions • Functions are first-class values • Currying • max :: (Int,Int)  Intmax (x,y) = if x > y then x else ymax(5,6)  6 • max :: Int  (Int  Int)max x y = if x > y then x else ymax 5 6  6 • m5 :: Int  Intm5 = max 5 <==> m5 y = if 5 > y then 5 else ym5 4  5m5 6  6 In C, this would be int max(int, int); USTC

8. Haskell by Examples • Recursion • sum [] = 0sum (x:xs) = x +sum xs • prod [] = 1prod (x:xs) = x *prod xs • Higher-order functions improve modularization • Modularization is the key to successful programming! • fold f a [] = afold f a (x:xs) = f x (fold f a xs) • sum = fold (+) 0 • prod = fold (*) 1 • allTrue = fold (&&) True • anyTrue = fold (||) False USTC

9. Haskell by Examples • Lazy evaluation • Call-by-need • f x y = if x > 0 then x else y… f e1 e2 … • Infinite data structures • ones = 1 : ones  1 : 1 : 1 : 1 : 1 : … • numsFrom n = n : numsFrom (n+1) n : n+1 : n+2 : n+3 : … • squares = map (^2) (numsFrom 0) 0 : 1 : 4 : 9 : 16 : 25 : 36 : … • take 5 squares  [0, 1, 4, 9, 16] • fib = 1 : 1 : zipWith (+) fib (tail fib) 1 : 1 : 2 : 3 : 5 : 8 : 13 : … (+) 1 : 2 : 3 : 5 : 8 : 13 : 21 : … -------------------------------------1 : 1 : 2 : 3 : 5 : 8 : 13 : 21 : 34 : … USTC

10. Haskell by Examples • Lazy evaluation • Another powerful tool for improving modularity • sort xs = … take n xs = … smallest n x = take n (sort x) • Only practical for lazy languages • Need-driven: no unnecessary computation • No large intermediate data structure USTC

11. Haskell by Examples • Advanced type systems • Polymorphic • zipWith :: a,b,c.(abc)  [a]  [b]  [c] • Type inference • zipWith f [] _ = []zipWith f _ [] = []zipWith f (x:xs) (y:ys) = f x y : zipWith f xs ys • a  [b]  c  [d] refine a  [b]  [e]  [d] refine (b  e  d)  [b]  [e]  [d]rename (a  b  c)  [a]  [b]  [c] USTC

12. Roadmap • Programming languages research at Yale • Introduction to Haskell •  Domain specific languages • FRP • Haskore • Conclusions and video USTC

13. Animation in a General-Purpose Language • Sketch of the code (taken from Elliott’s Fran manual): allocate and initialize window, various drawing surfaces and bitmaps repeat until quit: get time ( t ) clear back buffer for each sprite (back to front): compute position, scale, etc. at t draw to back buffer flip back buffer to the screen deallocate bitmaps, drawing surfaces, window • Lots of tedious, low-level code that you have to write yourself • There is a better way! USTC

14. We Need Domain Specificity • A domain-specific language (or DSL) is a language that precisely captures a domain semantics; no more, and no less. • Examples • SQL, UNIX shells, Perl, Prolog • FRP, Haskore USTC

15. Advantages of DSL Approach • Programs in the target domain are: • more concise • quicker to write • easier to maintain • easier to reason about • can often be written by non-programmers Contribute to higher programmer productivity Dominant cost in large SW systems Verification, transform- ation, optimization These are the same arguments in favor of any high-level language. But in addition: Helps bridge gap between developer and user

16. The Bottom Line Conventional Total SW Cost Methodology C2 Start - up DSL - based Costs Methodology C1 Software Life-Cycle USTC

17. DSL’s Allow Faster Prototyping Using the “Spiral Model” of Software Development specify design specify design build test build test Without DSL With DSL USTC

18. Roadmap • Programming languages research at Yale • Introduction to Haskell • Domain specific languages •  FRP • Haskore • Conclusions and video USTC

19. reactive system responses stimuli environ-ment Reactive Programming • Reactive systems • Continually react to stimuli • Environment cannot wait – system must respond quickly • Run forever • Examples • Computer animation • GUI • Robotics • Vision • Control systems • Real-time systems USTC

20. behavior time time event Functional Reactive Programming • Functional Reactive Programming (FRP) • Focuses on model instead of presentation • Continuous time domain • Discrete time domain • Recursion + higher-order functions • Originally embedded in Haskell • Continuous/discrete signals • Behaviors: values varying over time • Events: discrete occurrences • Reactivity: b1 ‘until‘ ev -=> b2 • Combinators: until, switch, when, integral, etc USTC

21. What Is FRP Good for? • Applications of FRP • Fran [Elliott and Hudak] Interactive animation • Frob [Peterson, Hager, Hudak and Elliott] Robotics • FVision [Reid, Peterson, Hudak and Hager] Vision • Frappé[Courtney] Java • FranTk [Sage], Fruit [Courtney] GUI moveXY (sin time) 0 charlotte charlotte = importBitmap “charlotte.bmp” USTC

22. Basic Concepts • Behaviors (Behavior a) • Reactive, continuous-time-varying values time :: Behavior Time mouse :: Behavior Point2 • Events (Event a) • Streams of discrete event occurrences lbp :: Event () • Switching b1 `till` lbp -=> b2 • Combinators • Behaviors and events are both first-class • Passed as arguments • Returned by functions • Composed using combinators USTC

23. Behaviors • Time time :: Behavior Time • Input mouse :: Behavior Point2 • Integration integral :: Behavior Double -> Behavior Double (integral time) • Constant behaviors lift0 :: a -> Behavior a (lift0 5) USTC

24. Lifting • Static value -> behavior lift0 :: a -> Behavior a lift1 :: (a -> b) -> Behavior a -> Behavior b lift2 :: (a -> b -> c) -> Behavior a -> Behavior b -> Behavior c ... • Examples lift1 sin time  sin time lift2 (+) (lift0 1) (lift1 sin time)  1 + sin time time time USTC

25. Simple Behaviors demo • Hello, world! hello :: Behavior Picture hello = text $ lift0 "Hello, world!" main1 = animate hello • Interaction: mouse-following main2 = animate $ moveTo mouse hello • Time main3 = animate $ text $ lift1showtime USTC

26. Geometry in FRP • 2-D • Points • Vectors • Common shapes • Circle, line, polygon, arc, and etc • Affine transformations • Rotation • Translation • Reflection • Scaling • Shear • Composition of the above • 3-D as well USTC

27. Spatial Transformations demo • Spatial transformations -- dancing ball ball :: Behavior Picture ball = withColor red $ stretch 0.1 circle wiggle, waggle :: Behavior Double -> Behavior Double wiggle omega = sin (omega*time) waggle omega = cos (omega*time) main4 om1 om2 = animate $ moveXY (wiggle om1) (waggle om2) $ moveTo mouse ball USTC

28. Spatial Composition demo • Spatial composition -- dancing ball & text main5 = animate $ moveTo mouse $ moveXY (wiggle 4) (waggle 4) ball `over` moveXY (wiggle 7) (waggle 3) hello USTC

29. Recursive Behaviors • Damped motion of a mass dragged with a spring • Integral equations • Recursive d = pm – po a = ksd – kfv v =  a dt po =  v dt d pm v po ks d -kf v USTC

30. Recursive Behaviors (cont’d) demo • FRP Code main6 = animate $ moveTo po ball `over` withColor blue (line mouseB po) where ks = 1 kf = 0.8 d = mouse .-. po a = ks *^ d – kf *^ v v = integral a po = vector2ToPoint2 $ integral v • Declarative • Concise • Recursive d = pm – po a = ksd – kfv v =  a dt po =  v dt USTC

31. Switching demo • Switching of behaviors color :: Behavior Color color = red `till` lbp -=> blue mouseBall :: Behavior Picture mouseBall = moveTo mouse $ stretch 0.5 circle main7 = animate $ withColor color mouseBall • Recursive switching cycle3 c1 c2 c3 = c1 `till` lbp -=> cycle3 c2 c3 c1 main8 = animate $ withColor (cycle3 red green blue) mouseBall USTC

32. Paddle Ball in 17 Lines video • paddleball vel = walls `over` paddle `over` pball velwalls = let upper = paint blue (translate ( 0,1.7) (rec 4.4 0.05))             left  = paint blue (translate (-2.2,0) (rec 0.05 3.4))            right = paint blue (translate ( 2.2,0) (rec 0.05 3.4))         in upper `over` left `over` rightpaddle = paint red (translate (fst mouse, -1.7) (rec 0.5 0.05))pball vel =  let xvel    = vel `stepAccum` xbounce ->> negate      xpos    = integral xvel      xbounce = when (xpos >* 2 ||* xpos <* -2)      yvel    = vel `stepAccum` ybounce ->> negate      ypos    = integral yvel      ybounce = when (ypos >* 1.5                   ||* ypos `between` (-2.0,-1.5) &&*                      fst mouse `between` (xpos-0.25,xpos+0.25))  in paint yellow (translate (xpos, ypos) (ell 0.2 0.2))x `between` (a,b) = x >* a &&* x <* b USTC

33. Crouching Robots, Hidden Camera • RoboCup • Team controllers written in FRP • Embedded robot controllers written in C(our goal: use FRP instead) camera Team A controller Team B controller radio radio USTC

34. A Point-tracking Control System • Input • xd, yd, d: desired position & heading • x, y, : actual position & heading • Output • u: forward speed • v: rotational speed d (xd,yd) u  v (x,y) USTC

35. A Point-tracking System video u = u_d - k1 * z1 v = k2 * derivativeB theta_d – dTheta - r1 * z1 - r2 * z2 dTheta = lift1 normalizeAngle $ theta - theta_d u_d = derivativeB x_d * cos theta_d + derivativeB y_d * sin theta_d z1 = (x – x_d) * cos theta + (y – y_d) * sin theta z2 = (x – x_d) * sin theta – (y – y_d) * cos theta r1 = ifZ (abs dTheta <* 0.01) 0 (u_d*(1 - cos dTheta)/dTheta) r2 = ifZ (abs dTheta <* 0.01) (-u_d) (-u_d * sin dTheta / dTheta) USTC

36. Roadmap • Programming languages research at Yale • Introduction to Haskell • Domain specific languages • FRP •  Haskore • Conclusions and video USTC

37. Haskore Motivation: Traditional music notation has many limitations: • Unable to express a composer’s intentions. • Biased toward music that is humanly performable. • Unable to express notions of algorithmic composition.Haskore (“Haskell” + “Score”) is a library of Haskellfunctions and datatypes for composing music. USTC

38. Basic Haskore Structure type Pitch = (PitchClass, Octave) data PitchClass = Cf | C | Cs | Df | D | Ds | Ef | E | Es | Ff | F | Fs | Gf | G | Gs | Af | A | As | Bf | B | Bs type Octave = Int data Music = NotePitchDur -- a note | RestDur -- a rest | Music:+:Music -- sequential composition | Music:=:Music -- parallel composition | TempoIntIntMusic -- scale the tempo | TransIntMusic -- transposition | InstrINameMusic -- instrument label type Dur = Float -- in whole notes type IName = String type PName = String USTC

39. Gloveby Tom Makucevichwith help from Paul HudakComposed using Haskore, a Haskell DSL,and rendered using csound. USTC

40. Roadmap • Programming languages research at Yale • Introduction to Haskell • Domain specific languages • FRP • Haskore •  Conclusions and video USTC

41. Conclusions video • Haskell has changed the way many people think about programming. It is worth knowing! • Functional programming community have some good ideas. Let’s start using them! • Functional programming is fun! • Check out our web-site! • Haskell http://haskell.org/ • FRP http://haskell.org/frp/ • Haskore http://haskell.org/haskore/ • Hugs http://haskell.org/hugs/ • Life at Yale is fun! (See the video) USTC