Introduction To Haskell

Lecture 3

types :: type1 → type2

Using These Slides

Every slide has a secret note.

Shortcut Keys:

Haskell Programming

• Code lives in a file with a .hs extension


• Open the file with GHCi

  Run it from the terminal $ ghci myfile.hs

  Or run ghci, then load the file $ ghci Prelude> :load myfile

• Call your function through ghci

Previous Homework

-- Most popular solution
facA n = if n > 1 
         then n * facA(n-1) 
         else n










	    

-- Right tools for the right job
facB n = product [1..n]
	    

-- Oh, you.
facC n = foldr (*) 1 [1..n]
	    

-- Sophomore Haskell programmer
-- (studied Scheme as a freshman)
-- http://willamette.edu/~fruehr/haskell/evolution.html
facD = (\(n) ->
        (if ((==) n 0)
            then 1
            else ((*) n (facD ((-) n 1)))))
	    

-- Memoizing Haskell programmer
-- http://willamette.edu/~fruehr/haskell/evolution.html
facs = scanl (*) 1 [1..]
facE n = facs !! n
	    

-- Iterative Haskell programmer
-- (former Pascal programmer)
-- http://willamette.edu/~fruehr/haskell/evolution.html
facF n = result (for init next done)
        where init = (0,1)
              next   (i,m) = (i+1, m * (i+1))
              done   (i,_) = i==n
              result (_,m) = m

for i n d = until d n i
	    

-- Continuation-passing Haskell programmer
-- http://willamette.edu/~fruehr/haskell/evolution.html

facCps k 0 = k 1
facCps k n = facCps (k . (n *)) (n-1)

facG = facCps id
	    

-- Boy Scout Haskell programmer
-- http://willamette.edu/~fruehr/haskell/evolution.html

y f = f (y f)

facH = y (\f n -> if (n==0) then 1 else n * f (n-1))
	    

-- Combinatory Haskell programmer
-- http://willamette.edu/~fruehr/haskell/evolution.html
s f g x = f x (g x)

k x y   = x

b f g x = f (g x)

c f g x = f x g

y f     = f (y f)

cond p f g x = if p x then f x else g x

facI  = y (b (cond ((==) 0) (k 1)) (b (s (*)) (c b pred)))
	    

-- List-encoding Haskell programmer
-- (prefers to count in unary)
-- http://willamette.edu/~fruehr/haskell/evolution.html
arb = ()

listenc n = replicate n arb
listprj f = length . f . listenc

listprod xs ys = [ i (x,y) | x<-xs, y<-ys ]
                 where i _ = arb

facl []         = listenc  1
facl n@(_:pred) = listprod n (facl pred)

facJ = listprj facl
	    

Types

• Bool = False | True

• Char = 'a' | 'b' | ... | 'A' | 'B' | ...

• Int = -2³¹ | ... | -1 | 0 | 1 | ... | 2³¹-1

• Integer

• Double

Types always start with a capital letter

Everything has a Type

Haskell secretly infers that True is a Bool.

Prelude> :type True
True :: Bool
	    

Prelude> 3 :: Int
3

Prelude> 3 :: Double
3.0
	    

Yes, Functions have a Type

Prelude> head [1,2,3,4]
1

Prelude> :type head
head :: [a] -> a
	    

Prelude> fst ("left", "right")
"left"

Prelude> :type fst
fst :: (a, b) -> a
	    

Like a Jigsaw Puzzle

"if a piece has the wrong shape, it simply won't fit"

Haskell	Python*

What should be the type declaration for fac? (clear answer) (show answer)

fac n = product [1..n]
	    

fac :: Integer -> Integer
fac n = product [1..n]
	    

(&&) ::
	    

(&&) :: Bool -> Bool -> Bool
	    

Prelude> 0:[1,2,3]
[0,1,2,3]

Prelude> :type (:)

	    

Prelude> 0:[1,2,3]
[0,1,2,3]

Prelude> :type (:)
(:) :: a -> [a] -> [a]
	    

Google Tech Talk

(8:00 to 9:22)

Typeclass

A Typeclass lets you generalize a function.

• 10 < 20
• 'a' < 'b'
• "aardvark" < "zzz"
• [6,2,4] < [6,3,8]

The Ord Typeclass

is used for things with total order

Prelude> :type (<)

	    

Prelude> :type (<)
(<) :: a -> a -> Bool
	    

Prelude> :type (<)
(<) :: Ord a => a -> a -> Bool
	    

Similar to Interfaces

Remember them from Java?

public class NumberUsedByLessThanSign implements Comparable {
  ...
}
	    

Other Typeclasses

• Show - representable as a string

  
  Prelude> show 42
  "42"
  		

• Enum - enumerable in a list

  
  Prelude> ['R'..'t']
  "RSTUVWXYZ[\\]^_`abcdefghijklmnopqrst"
  		

• Num - usable as a number

  
  Prelude> 5.2 * 2.5
  13.0
  		

Have you noticed?

Functions with multiple arguments look funny.

Prelude> take 5 [1..]
[1,2,3,4,5]
	    

Prelude> :type take
take :: Int -> [a] -> [a]
	      

The Concept of Currying

All Haskell functions take only one argument

A Closer Look

at the take function:

take :: Int -> [a] -> [a]
	    

take :: Int -> ([a] -> [a])
	      

Partial Applications

Every function technically has one argument.

Actually, this is really cool!

Prelude> :type take
take :: Int -> [a] -> [a]

Prelude> let takeFive = take 5

Prelude> :type takeFive
takeFive :: [a] -> [a]

Prelude> takeFive [1..]
[1,2,3,4,5]
	    

Functional and Pure

A function only depends on its aguments.

A type declaration is a strong promise.

Focus on what is done, not how.

Inherently modular

Elegant

Get Our Hands Dirty

Create mycode.hs and write a function called zipTogether

-- mycode.hs
-- |The 'zipTogether' function binds together two lists.

zipTogether :: [a] -> [b] -> [(a,b)]

	    

-- mycode.hs
-- |The 'zipTogether' function binds together two lists.

zipTogether :: [a] -> [b] -> [(a,b)]
zipTogether [] [] = []
zipTogether [] ys = []
zipTogether xs [] = []
zipTogether xs ys = (head xs, head ys):
                          (zipTogether (tail xs) (tail ys))
	    

-- mycode.hs
-- |The 'zipTogether' function binds together two lists.

zipTogether :: [a] -> [b] -> [(a,b)]
zipTogether [] [] = []
zipTogether [] ys = []
zipTogether xs [] = []
zipTogether (x:xs) (y:ys) = (x,y) : zipTogether xs ys
	    

Expected output:

Prelude> zipTogether [1,2,3] "abc"
[(1,'a'),(2,'b'),(3,'c')]
	    

Homework

1. Write a Caesar Cipher function called cipher

   
   cipher :: [Char] -> Int -> [Char]
   
   		  

   
   Prelude> cipher "hello" 13
   "uryyb"
   		  

   Are you sure?

   (please show hint!)

   
   cipher :: [Char] -> Int -> [Char]
   cipher [] _ = []
   cipher (s:ss) n = (rotate s n) : (cipher ss n)
   
   rotate :: Char -> Int -> Char
   		  

   Now define this 'rotate' function

   (show hint)

2. Bonus points for a cool solution!

3. Submit this week's homework form!