San Diego Ruby: A Tour of Haskell

Transcript

1. A Tour of Haskell A Rubyist’s Take on Functional Programming

   Xavier Lange

2. Xavier • Ruby hacker • Detour to Erlang hacking •

   Drank the functional Kool-Aid • Went back to Ruby • Tried some Haskell

3. You can never understand a language until you understand at

   least two. – Ron Searle

4. • You manipulate values not state • Functions are values

   • Recursion is idiomatic Well, a language is functional if...

5. Haskell is a functional language and... • All the pieces

   fit together before it runs • “strongly-typed” • Work is only done when you need it • “lazy”, “demand-driven” • Don’t need all the arguments • “currying”

6. Other features of Haskell • The Glasgow Haskell Compiler •

   optimizing compiler • emits standalone executables • or libraries

7. Other features of Haskell (cont.) • Hackage • Large library

   ecosystem • Cabal build system • Standardized • Ubiquitous • Manage dependencies

8. Ruby http://avatarbriefs.blogspot.com/2012/06/duck-friday_15.html

9. Haskell http://playducation.blogspot.com/2010/05/wooden-shape-sorters-are-favourite.html

10. Haskell Makes a Quiet Introduction

11. #!/usr/bin/env runhaskell main = do putStrLn "hello SDRuby!"

12. Interpreter #!/usr/bin/env runhaskell main = do putStrLn "hello SDRuby!"

13. Defines a function #!/usr/bin/env runhaskell main = do putStrLn "hello

    SDRuby!"

14. Please, ignore :) #!/usr/bin/env runhaskell main = do putStrLn "hello

    SDRuby!"

15. A list of chars #!/usr/bin/env runhaskell main = do putStrLn

    "hello SDRuby!"

16. Function Application #!/usr/bin/env runhaskell main = do putStrLn "hello SDRuby!"

17. Easy, right?

18. Some Types 3 :: Integer "3" :: String "3" ::

    [Char] 1.0 :: Float True :: Bool False :: Bool [1,2,3] :: [Integer]

19. Learn by Starting Over

20. data Bool = True | False

21. data Bool = True | False Type

22. data Bool = True | False Value Constructor

23. data Bool = True | False Value Constructor

24. not :: Bool -> Bool not True = False not

    False = True

25. (&&) :: Bool -> Bool -> Bool False && _

    = False True && x = x

26. Your first container data List a = Nil | Cons

    a (List a)

27. data List a = Nil | Cons a (List a)

    cons :: a -> List a -> List a cons x xs = Cons x xs

28. data List a = Nil | Cons a (List a)

    Nil => Nil cons 1 Nil => Cons 1 Nil cons 2 (cons 1 Nil) => Cons 2 (Cons 1 Nil) cons 3 (cons 2 (cons 1 Nil)) => Cons 3 (Cons 2 (Cons 1 Nil))

29. length :: List a -> Integer

30. data List a = Nil | Cons a (List a)

    length :: List a -> Integer length Nil = 0 length Cons _ rest = 1 + (length rest)

31. length (Cons 3 (Cons 2 (Cons 1 Nil))) 1 +

    (length (Cons 2 (Cons 1 Nil))) 1 + 1 + (length (Cons 1 Nil)) 1 + 1 + 1 + (length Nil) 1 + 1 + 1 + 0 2 + 1 + 0 3 + 0 3

32. A Note On Laziness • In ruby • Elements of

    list must be built first • In Haskell • Elements of list are built when needed

33. Case in Point zipWith and lazy lists

34. [1..] :: (Enum t, Num t) => [t]

35. zipWith :: (a -> b -> c) -> [a] ->

    [b] -> [c]

36. zipWith :: (a -> b -> c) -> [a] ->

    [b] -> [c] (+) :: Num a => a -> a -> a zipWith (+) [10,11,12] [1..] [11,13,15] zipWith (,) [10,11,12] [1..] [(10,1),(11,2),(12,3)]

37. zipWith (+) [10,11,12] [1,1..] [11,12,13] zipWith (,) [10,11,12] [1,1..] [(10,1),(11,1),(12,1)]

38. OK, Where Does Haskell Really Shine?

39. Where Does It Sparkle and Boom?

40. data FireShow = Expl ExplType Dur | Rest Dur --

    sequential | FireShow :+: FireShow -- parallel | FireShow :=: FireShow

41. type Dur = Integer data ExplType = Sparkle | Bang

    | Red | White | Blue | SmileyFace

42. sanDiegoShow :: FireShow sanDiegoShow = (((Expl Sparkle 5) :=: (Expl

    Red 10)) :=: ((Expl Bang 7) :=: (Expl Sparkle 4))) :=: (((Rest 10) :=: (Rest 10))) :=: ((Expl Red 10) :=: (Expl White 10))

43. Did You See $125k Problem? http://www.foxnews.com/us/2012/07/05/san-diego-fireworks-malfunction-in-big-fast-flash/

44. @benballer, 7/4/2012

45. data FireShow = Expl ExplType Dur | Rest Dur --

    sequential | FireShow :+: FireShow -- parallel | FireShow :=: FireShow duration :: FireShow -> Dur duration (Expl _ dur) = dur duration (Rest dur) = dur duration (lShow :+: rShow) = (duration lShow) + (duration rShow) duration (lShow :=: rShow) = greaterOf (duration lShow) (duration rShow)

46. -- greaterOf :: Dur -> Dur -> Dur greaterOf lDur

    rDur | lDur > rDur = lDur | otherwise = rDur

47. sanDiegoShow :: FireShow sanDiegoShow = (((Expl Sparkle 5) :=: (Expl

    Red 10)) :=: ((Expl Bang 7) :=: (Expl Sparkle 4))) :=: (((Rest 10) :=: (Rest 10))) :=: ((Expl Red 10) :=: (Expl White 10)) duration sanDiegoShow => 10

48. xaviersShow :: FireShow xaviersShow = (((Expl Sparkle 5) :=: (Expl

    Red 10)) :+: ((Expl Bang 7) :=: (Expl Sparkle 4))) :+: (((Rest 10) :=: (Rest 10))) :+: ((Expl Red 10) :=: (Expl White 10)) duration xaviersShow => 37

49. #BigBayBoom fail averted with Haskell? News at 11.

50. In Any Language You Model Your Problem Domain

51. Functional Modeling is Value-Oriented

52. Recursive Values Are Your Friend

53. Is laziness worth it? • Instead of doing unused work

    your runtime does book-keeping • Now in Ruby 1.9.2+ • Not quite as idiomatic identity = lambda{|x,y| x+y}.curry.(0)

54. Haskell is a big subject • Takes time to sink

    in • Be patient • And remember your goal...

55. Thanks • Feel free to email me, [email protected] • Or

    say hi @tureus