2018-11-14 13:10

Types in Haskell

Haskell is a strongly typed language.
- All values have a type. All type errors are reported, you can't escape the type system.
Haskell is a statically typed language.
- Types are checked at compile-time (before the program is run).
Haskell supports type inference and polymorphism.
- If you omit the type, Haskell infers a type automatically.
- Most of the time it doesn't need to guess, there is one type that is the best type.

Predefined types

�
```
Bool�
```
: ‹False›, ‹True›.
�
```
Int�
```
, �
```
Integer�
```
: ‹0›, ‹1›, ‹-5›, ‹42›
�
```
Float�
```
, �
```
Double�
```
: ‹0.0›, ‹3.14›, ‹1.5e9›, ‹-1.0›
�
```
Char�
```
: ‹'A'›, ‹'B'›, ‹'x'›, ‹'/'›, ‹'\n'›.
�
```
String�
```
: ‹""›, ‹"Haskell"›, ‹"Hello world!\n"›

Collections of things

Tuples

t1 = (False, 42) :: (Bool,Int)

t2 = ("Hello",False,5) :: (String,Bool,Int)

t3 = ("Haskell",True,4,0.5) :: (String,Bool,Int,Double)

t0 = () :: ()    -- the empty tuple

Collections of things

Lists

l1 = [2,3,5,7,11] :: [Integer]

l2 = ["Hello","world"] :: [String]

l3 = [] :: [Bool]

l4 = [] :: [Int]   -- the empty list has many types

Maybe and Either

Maybe

data Maybe a = Nothing | Just a

m1 = Nothing :: Maybe a
m2 = Just "Hello" :: Maybe String

Either

data Either a b = Left a | Right b

e1 = Left "Hello" :: Either String b
e2 = Right 42 :: Either a Int
e3 = [Right 42,Left "Hello"] :: [Either String Int]

Function types

power :: Integer -> Integer -> Integer

exampleFunction :: (Bool, Int, String) -> Bool

doubles :: [Integer] -> [Integer]

summary :: [String] -> String

Types can be combined in arbitrary ways

�
```
[[Double]]�
```
�
```
[(Int,String)]�
```
�
```
([Int],[String])�
```
�
```
[(Int,[String])]�
```

Function types too!

�
```
[(Int->String,[Int])] -> String�
```
�
```
[(a->b,a)] -> [b]�
```

Polymorphism (generic functions)

length :: [a] -> Int

(++)    :: [a] -> [a] -> [a]

fst     :: (a,b) -> a

map     :: (a -> b) -> [a] -> [b]

filter  :: (a->Bool) -> [a] -> [a]

The same implementation works for all types. Parametricity.

Overloading (restricted polymorphism)

show :: Show a => a -> String

(+),(*) :: Num a => a -> a -> a

(==) :: Eq a => a -> a -> Bool

(<), (<=) :: Ord a => a -> a -> Bool

Name reuse. Different implementations are needed for different types.