From Ruby to Haskell (Kansai Yami RubyKaigi)

From Ruby to Haskell
Kansai Yamiruby Kaigi
Nov 13, 2011
Tatsuhiro Ujihisa

Sunday, November 13, 2011

Agenda
• Haskell (introduction)
• Haskell (for beginners)
• Self-introduction
• Haskell (for average people)
• Haskell (for pro)


Haskell (1/3)


Haskell
• Programming language
• 1990~
• GHC


Haskell
• Strong static-typed
• Interpreter & native compiler
• Lazy evaluation

main = print "hello"


FizzBuzz in Ruby
1 (1..100).each do |i| 1 def main
2 puts ﬁzzbuzz
2 puts i % 15 == 0 ? 'FizzBuzz' :
3 end
3 i % 5 == 0 ? 'Buzz' :
4
4 i % 3 == 0 ? 'Fizz' : 5 def ﬁzzbuzz
5 i 6 (1..100).map {|i|
6 end 7 i % 15 == 0 ? 'FizzBuzz' :
8 i % 5 == 0 ? 'Buzz' :
9 i % 3 == 0 ? 'Fizz' :
10 i
11 }
12 end
13
14 main


FizzBuzz in Ruby
1 def main 1 def main
2 puts fizzbuzz 2 puts fizzbuzz
3 end 3 end
4 4
5 def fizzbuzz 5 def fizzbuzz
6 f = -> i do 6 (1..100).map {|i|
7 i % 15 == 0 ? 'FizzBuzz' : 7 i % 15 == 0 ? 'FizzBuzz' :
8 i % 5 == 0 ? 'Buzz' : 8 i % 5 == 0 ? 'Buzz' :
9 i % 3 == 0 ? 'Fizz' : 9 i % 3 == 0 ? 'Fizz' :
10 i 10 i
11 end 11 }
12 (1..100).map &f 12 end
13 end 13
14 14 main
15 main

FizzBuzz in Haskell
1 def main 1 main = print fizzbuzz
2 puts fizzbuzz 2
3 end 3 fizzbuzz = map f [1..100]
4 4 where f n
5 def fizzbuzz 5 | n `rem` 15 == 0 = "FizzBuzz"
6 f = -> i do 6 | n `rem` 5 == 0 = "Buzz"
7 i % 15 == 0 ? 'FizzBuzz' : 7 | n `rem` 3 == 0 = "Fizz"
8 i % 5 == 0 ? 'Buzz' : 8 | otherwise = show n
9 i % 3 == 0 ? 'Fizz' :
10 i
11 end
12 (1..100).map &f
13 end
14
15 main

Haskell (2/3)


1 main = print (a + b) 1 main = print (a + b)
2 a=1 2 a = 1 :: Int
3 b=2 3 b :: Int
4 b=2

1 main = print (a + b)
2 a = 1 :: Int
1 a.hs:4:5:
3 b :: Int 2 No instance for (Fractional Int)
4 b = 2.1 3 arising from the literal `2.1'
4 Possible ﬁx: add an instance declaration for (Fractional Int)
5 In the expression: 2.1
6 In an equation for `b': b = 2.1
7


Type and type-class
• type (in Haskell) =~ class (in Ruby)
• type class (in Haskell) =~
module (in Ruby)

• Int type =~ Fixnum class
• Num type-class =~ Numeric module


Literals
• Ruby: only one type
• 1 (always Fixnum)
• "hello" (always String)
• Haskell: compiler infers
• 1 (Int? Integer? Float? Rational?)
• "a" (String? Test? ByteString?)

error 2 a = 1 :: Int
3 b = 2.1

ok 2 a=1
3 b = 2.1

b and (a+b) can be Float, Double or Rational


Lists
• [1, 2, 3]
• 1 : 2 : 3 : []
• ["a", "b", "c"]
• [1, 2, "a"] ERROR


Functions
• call
• fa
• gab
• deﬁne
• f a = something
• g a b = something

Operators
• call
• 1+2
• (+) 1 2
• 1 `g` 2
• deﬁne
• a + b = something

Interesting operators
•$
• f (g (h a b)))
• f$g$hab
• a : b : c : [] == [a, b, c]
• expected @=# actual


Combining actions
main = print [1, 2, 3] >> print "hi"

1 main = do
2 print [1, 2, 3]
3 print "hi"

main = do { print [1, 2, 3]; print "hi" }


only for side eﬀect
• Ruby
• puts 'hi'
puts 'yo'
• Haskell • puts 'hi'; puts 'yo'
• do
putStrLn "hi"
putStrLn "yo"
• putStrLn "hi" >> putStrLn "yo"

side eﬀect to get a val
• Ruby •Haskell
• a = gets • do
pa a <- getContent
print a
• getContent >>= print


self-introduction


Tatsuhiro Ujihisa
• @ujm
• Vancouver
• HootSuite media inc
• Vim


• http://ujihisa.blogspot.com
• http://vim-users.jp
• http://github.com/ujihisa


Haskell (3/3)


re: FizzBuzz in Haskell
1 def main 1 main = print fizzbuzz
2 puts fizzbuzz 2
3 end 3 fizzbuzz = map f [1..100]
4 4 where f n
5 def fizzbuzz 5 | n `rem` 15 == 0 = "FizzBuzz"
6 f = -> i do 6 | n `rem` 5 == 0 = "Buzz"
7 i % 15 == 0 ? 'FizzBuzz' : 7 | n `rem` 3 == 0 = "Fizz"
8 i % 5 == 0 ? 'Buzz' : 8 | otherwise = show n
9 i % 3 == 0 ? 'Fizz' :
10 i
11 end
12 (1..100).map &f
13 end
14
15 main

output
1 main = print ﬁzzbuzz ["1","2","Fizz","4","Buzz","Fiz
2 z","7","8","Fizz","Buzz","11","
3 ﬁzzbuzz = map f [1..100] Fizz","13","14","FizzBuzz","16
4 where f n ","17","Fizz","19","Buzz","Fizz
","22","23","Fizz","Buzz","26",
5 | n `rem` 15 == 0 = "FizzBuzz"
"Fizz","28","29","FizzBuzz","3
6 | n `rem` 5 == 0 = "Buzz"
1","32","Fizz","34","Buzz","Fiz
7 | n `rem` 3 == 0 = "Fizz" z","37","38","Fizz","Buzz","41
8 | otherwise = show n ","Fizz","43","44","FizzBuzz","
46","47","Fizz","49","Buzz","F
izz","52","53","Fizz","Buzz","5
6","Fizz","58","59","FizzBuzz"
,"61","62","Fizz","64","Buzz","
like p Fizz","67","68","Fizz","Buzz","
71","Fizz","73","74","FizzBuzz
","76","77","Fizz","79","Buzz",
"Fizz","82","83","Fizz","Buzz",

output
1
1 main = mapM_ putStrLn ﬁzzbuzz 2
2 Fizz
4
3 ﬁzzbuzz = map f [1..100] Buzz
4 where f n Fizz
7
5 | n `rem` 15 == 0 = "FizzBuzz" 8
6 | n `rem` 5 == 0 = "Buzz" Fizz
Buzz
7 | n `rem` 3 == 0 = "Fizz" 11
Fizz
8 | otherwise = show n 13
14
FizzBuzz
16
17
Fizz
19
like puts Buzz
Fizz
22
23
Fizz

mapM_
• f x >> f y >> f z
• do
fx
fy
fz
• mapM_ f [x, y, z]


mapM_
• ((f x) >> f y) >> f z
• foldl1 (>>) $ map f [x, y, z]
• f x >> (f y >> (f z))
• foldr1 (>>) $ map f [x, y, z]
• sequence_ (map f [x, y, z])

1 main = mapM_ putStrLn fizzbuzz 1 main = mapM_ putStrLn fizzbuzz
2 2
3 fizzbuzz = map f [1..100] 3 fizzbuzz = map f [1..100]
4 where f n 4 where f n = case () of
5 | n `rem` 15 == 0 = "FizzBuzz" 5 n `rem` 15 == 0 -> "FizzBuzz"
6 | n `rem` 5 == 0 = "Buzz" 6 n `rem` 5 == 0 -> "Buzz"
7 | n `rem` 3 == 0 = "Fizz" 7 n `rem` 3 == 0 -> "Fizz"
8 | otherwise = show n 8 otherwise -> show n


map, flip, and for
• map f list
• flip map list f
• mapM_ f list
• flip mapM_ list f
• forM_ list f

1 main = mapM_ putStrLn ﬁzzbuzz
2
3 ﬁzzbuzz = map f [1..100]
4 where f n = case () of _
5 | n `rem` 15 == 0 -> "FizzBuzz"
6 | n `rem` 5 == 0 -> "Buzz"
7 | n `rem` 3 == 0 -> "Fizz"
1 import Control.Monad (forM_)
8 | otherwise -> show n
2 main = forM_ [1..100] f
3 where
4 f n = putStrLn $ case () of _
5 | n `rem` 15 == 0 -> "FizzBuzz"
6 | n `rem` 5 == 0 -> "Buzz"
7 | n `rem` 3 == 0 -> "Fizz"


1 import Control.Monad (forM_)
2 main = forM_ [1..100] $ n ->
3 putStrLn $ case () of _
4 | n `rem` 15 == 0 -> "FizzBuzz"
5 | n `rem` 5 == 0 -> "Buzz"
6 | n `rem` 3 == 0 -> "Fizz"
1 import Control.Monad (forM_)7 | otherwise -> show n
2 main = forM_ [1..100] f
3 where
4 f n = putStrLn $ case () of _
5 | n `rem` 15 == 0 -> "FizzBuzz"
6 | n `rem` 5 == 0 -> "Buzz"
7 | n `rem` 3 == 0 -> "Fizz"


Haskell as shell scripts
• Succinct expressions
• Powerful list-manipulation
• Powerful text-manipulation
• Reasonably fast to boot
• Healthy


Parsec
• Parser combinators
• Standard library
• No need for handling state
explicitly


Haskell web framework
• Yesod
• Snap (framework)
•


Appendix
• IDE-integration
• run on the IDE
• keyword completion
• Prelude type/function completion
• module name completion
• third party t/f completion
• pragma completion

quickrun.vim
• DEMO
• runghc
• ghc


From Ruby to Haskell (Kansai Yami RubyKaigi)

More Related Content

Viewers also liked (6)

Similar to From Ruby to Haskell (Kansai Yami RubyKaigi) (20)

More from ujihisa (20)

Recently uploaded (20)

From Ruby to Haskell (Kansai Yami RubyKaigi)