Transcript Haskell - Colorado School of Mines

Haskell
Chapter 2
Chapter 2



Type inference
Type variables
Type classes
What type is that?

:t expression => type

:t ‘a’



:t [ ]




‘a’ :: Char
read “a has type of Char”
[] :: [a]
[] denotes a list
tuples have unique types
:t (1,2)

(1,2) :: (Num t1, Num t) => (t, t1)
Specify type declaration for fn
removeNonUpperCase :: [Char] -> [Char]
removeNonUppercase st = [c | c <- st, c `elem` ['A'..'Z']]

takes a list of characters, returns a list of characters
addThree :: Int -> Int -> Int -> Int
addThree x y z = x + y + z


takes 3 integers, returns an integer
Syntax for addThree is covered in chapter 5
Common Data Types
Type names start with capital letters.
 Int. Bounded whole number.
 Integer. Really big whole numbers.
 Float. Single precision.
 Double. Double precision.
 Bool. True and False.
 Char. Unicode character.
 Tuples. Also empty tuple ()
Don’t begin your function names with upper case!
Type variables/Polymorphic types
Some functions can operate on various types (e.g., list
functions)
:t head
head :: [a] -> a
 Takes a list of any type, returns that type
 Notice the type variable is lower case
 Convention is to use 1-character names for type vars
:t fst
fst :: (a, b) -> a
 Notice two different letters, types don’t need to match

Type classes


Interface that defines some behavior
If a type is an instance of that type class, then it supports that
behavior
If you decide to make a type an instance of a type class, you
must define the behaviors associated with that type class.
:t (==)
(==) :: Eq a => a -> a -> Bool
 => is a class constraint
 Read as: “The equality function takes two values that are of the
same type and returns a Bool. The type of those two values
must be an instance of the Eq class.”

Common Type Classes

Eq



== and /=
an Eq constraint for a type variable means the function uses ==
or /= somewhere in its definition*
Ord



Values can be put in some order
>, <, >=,<=,compare
Being an Eq is a prereq for Ord
* how does this compare to C++ templates? Java?
Common Type Classes, continued

Show




values can be represented as strings
commonly used by show, e.g., show 3 => “3”
cannot “show” a function, e.g., “show doubleMe” is not valid
Read





Takes a string and returns a value whose type is an instance of Read
read "2" + 4.5
Needs to know what type to return, can’t just do: read "2"
Can use type annotation: read "2" :: Int
Remember: Haskell is statically typed. Doesn’t actually “read” until
execution… but type needs to be decided at compile time.
Common Type Classes, continued

Enum





Sequentially ordered types
Values can be enumerated
Have defined successors (succ) and predecessors (pred)
(), Bool, Char, Ordering, Int, Integer, Float, Double are Enum
Bounded



minBound and maxBound
maxBound :: Int
type is (Bounded a) => a - polymorphic constants
Common Type Classes, continued

Num







numeric, instances act like numbers
:t 20
20 :: Num a => a
Also polymorphic constants
:t (*)
(*) :: Num a => a -> a -> a
NOTE: Num a is no longer Show a. Sometimes you need both
in the type declaration, e.g., (Num a, Show a) => (a, a) -> a
Common Type Classes, continued

Integral








Includes only whole numbers (Int and Integer)
fromIntegral :: (Integral a, Num b) => a -> b
Multiple class constraints (a and b)
Takes an integral value and converts it into more general
number
:t length
length :: [a] -> Int
length [1,2,3] + 5.5 – Error!
fromIntegral (length [1,2,3]) + 5.5


Very useful, because Haskell doesn’t convert integral to floating point
automatically.
8.5
Play (no share)

Spend 5-10 minutes



tryout the :t command
play with show and read
play with fromIntegral