# Haskell

Part 3

# Recap

## :t <something>

## :i <something>

## GHC.IO

# Defining stuff

```
let count = 1
let add x y = x + y
let v = 2 :: Int
let h = 3 :: Float
```

# Calling functions

```
add 1 2
let add10 = add 10
```

# Basic Types

## 'c', False,"123", 1, [1,2,3], (1,True)

# Lists

## Can only be of single type

## (++), (:), (!!)

## head, tail, last, init

## length, reverse, drop, take

## sum, product, minimum, maximum, elem

# Ranges

## [1..20], ['a'..'z'], ['V'..'Z']

## [1,2..20]

## cycle, repeat, replicate,

# List comprehensions

`[x*2 | x <- [1..10], x*2 >= 12] `

`[ x*y | x <- [2,5,10], y <- [8,10,11]] `

`[x*2 | x <- [1..10]] `

# Tuples

fst, snd, zip

# In Haskell

## Everything has a type

`(+1) :: Int -> Int`

`(+) :: Int -> Int -> Int`

# Typeclasses

## Things that defines behaviour

# Not like classes

## Think of them as interfaces

instead.

# Example

`:t (==)`

## == is actually a function.

## So is +, -, /, * and almost all operators.

# The Eq Typeclass

## for types that support equality testing.

## Almost all of the standard types

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

Everything before => is called a *class constraint*

The (==) function takes two values of the same type and returns a Bool.

The type of the two types must be a member of the the Eq typeclass,

# The elem function

## has the type

`elem :: (Eq a) => a -> [a] -> Bool`

## because it uses the (==) function over a list to check whether it contains the value we are looking for

# Example

```
data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
deriving (Eq)
```

`Mon == Fri`

`Fri /= Wed`

# The Ord Typeclass

## for types that have ordering

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

`:t (<)`

# Example

```
data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
deriving (Eq, Ord)
```

`Mon > Fri`

`Fri > Wed`

# The Enum Typeclass

## for types that are sequentially ordered

## allows you to use them in list ranges

# Example

```
data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
deriving (Enum)
```

`[Mon..Fri]`

`succ Fri`

`pred Fri`

# The Show Typeclass

## Example

```
data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
deriving (Show)
```

`show Fri`

# The Read Typeclass

## Example

```
data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun
deriving (Read)
```

`read "Fri"`

# The Num Typeclass

## for types that act like numbers

# Type of a number

`13 :: (Num t) => t `

`:t 13`

# Whole numbers can act like

## any type that's a member of Num

`:t 13 :: Int`

`:t 13 :: Float`

`:t 13 :: Double`

`:t (+)`

`(+) :: (Num a) => a -> a -> a `

## So you can add numbers like so:

`(1 :: Double) + (3 :: Int)`

# Functor

is just another typeclass

# What behaviour does it define?

# Context

## A value can be wrapped in a context

# The Maybe type

`data Maybe a = Nothing | Just a`

```
2 -- a normal value
Just 2 -- a type of context wrapping a value
Nothing -- an empty type of context
```

```
Nothing :: Maybe a
```

```
Just :: a -> Maybe a
```

# When a value is wrapped in a context (eg a list, or maybe)

## You can't apply a normal function to it.

*fmap*

##
*fmap *knows how to apply a function to a value in a context

```
> fmap (+3) (Just 2)
Just 5
```

```
> fmap (+3) Nothing
Nothing
```

```
class Functor f where
fmap :: (a -> b) -> f a -> f b
```

To make datatype *f* a functor

You'll need to implement this function for your data type

# Pattern Matching

```
isOne :: Int -> Bool
isOne 1 = True
isOne _ = False
```

```
pow :: Int -> Int -> Int
pow _ 0 = 1
pow a b = a^b
```

```
instance Functor Maybe where
fmap function (Just x) = Just (function x)
fmap function Nothing = Nothing
```

`fmap (+3) (Just 2)`

`fmap (+3) Nothing`

# Another Example

`fmap (+3) [2,4,6]`

```
instance Functor [] where
fmap = map
```

# That's all for this week

## Questions?

That's all folks

# Applicatives

#### Haskell

By ..