2019-09-05 21:32

Page 1

Datatypes & Modelling

Page 2

But first

A quick look at predefined functions and types
A quick review of what we did last time
- Improving a few things
- Redo the QuickCheck example

Page 3

Values and types in Haskell

All values in Haskell belong to a type.

Here are some predefined types:

Type	Values
Integer	all integers, …, `-`2 , 1 , 0 , 1 , 2 , 3 , …
Int	limited size integers, typically -2⁶³ … 2⁶³-1
Float , Double	floating point numbers, e.g. 0.25 , `-`3.5 , `pi` , 1.5e6
Bool	False , True
[Int] , [Bool] , …	lists, e.g. [] , [1,2,5] , [True] , [[1,2],[3,4]]
Char	characters, e.g. 'H' , 'a' , '5' , '+'
String	text, e.g. "Hello world" , "Haskell"
(Int,Bool) , (String,Double) , …	pairs, e.g. (42,True) , ("Prawns",245.00)

Haskell also lets you define your own types…

Page 4

Functions and types in Haskell

All functions in Haskell have a type, for example

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

inside :: Double -> Double -> Bool
inside x y = x^2 + y^2 < 4

A function type describes what type of arguments (inputs) the function expects and what the type of the result (output) is.
Programs are type checked before they run. If a type mismatch is detected, it is reported in error message.
- GHC's type error messages can be rather cryptic, so
  - add type signatures to your functions,
  - :reload often

Page 5

Predefined functions in Haskell

A Tour of the Haskell Prelude: a collection various predefined functions.
- You can also find this link on the course home page under Course literature etc.

Page 6

Modelling Data

A big part of designing software is modelling the data in an appropriate way.
A lot of data can be represented as numbers or lists or other predefined types, but…
Today's lecture: we look at how to model data by defining new types in Haskell.
- This can make the code clearer and help prevent certain mistakes that otherwise easily happen.

Page 7

Modelling Playing Cards

Consider playing cards used in card games.
Every card has a suit. ♠ ♥ ♦ ♣
We can defined a new type for suits:

data Suit = Spades | Hearts | Diamonds | Clubs

Note that both the names of types (here
```
Suit
```
) and constructors should start with an upper-case letter.

Page 8

Live Demo

Source code: DataTypes.hs

Page 9

Showing Values

Spades <interactive>:3:1: error: • No instance for (Show Suit) arising from a use of ‘print’ • ...
Fix

data Suit = Spades | Hearts | Diamonds | Clubs
            deriving Show

Page 10

The colours of cards

Each suit has a colour – red or black
Model colours by a type

data Colour = Black | Red
              deriving Show

Define functions by pattern matching

colour :: Suit -> Colour
colour Spades   = Black
colour Hearts   = Red
colour Diamonds = Red
colour Clubs    = Black

One equation per case in the type of the argument

Page 11

Combining similar cases

colour :: Suit -> Colour
colour Spades = Black
colour Clubs  = Black
colour s      = Red

Or, by using the wild card (don't care) pattern:

colour :: Suit -> Colour
colour Spades = Black
colour Clubs  = Black
colour _      = Red

Useful if there are many cases, but only a few of them needs to be treated separately.

Page 12

Incomplete patterns

What happens if some cases are missing (by mistake)?

colour :: Suit -> Colour
colour Spades = Black
colour Clubs  = Black
coluor _      = Red

GHCi does not report an error, but the function
```
colour
```
can crash when we use it:
colour Diamonds *** Exception: DataTypes.hs:(19,1)-(20,23): Non-exhaustive patterns in function colour

Page 13

Incomplete patterns

There is a warning you can turn on to detect this:

:set -Wincomplete-patterns :load DataTypes.hs DataTypes.hs:19:1: warning: [-Wincomplete-patterns] Pattern match(es) are non-exhaustive In an equation for ‘colour’: Patterns not matched: Hearts Diamonds
Another warning that could be useful: -Wmissing-signatures

Page 14

The Ranks of Cards

Cards have ranks: 2, 3 .. 10, J, Q, K, A

data Rank = Numeric Int | Jack | Queen | King | Ace
            deriving Show

:t Numeric Numeric :: Int -> Rank Numeric 3 Numeric 3
Constructors are not just atomic units, they can carry additional information.

Page 15

Rank Beats Rank

```
rankBeats :: Rank -> Rank -> Bool
```
How many cases do we need to consider?
- There are five cases in the
```
Rank
```
  type.
- We have two arguments of type
```
Rank
```
  .

Page 16

Rank Beats Rank

rankBeats :: Rank -> Rank -> Bool
rankBeats _ Ace = False    -- nothing beats an Ace

Page 17

Rank Beats Rank

rankBeats :: Rank -> Rank -> Bool
rankBeats _ Ace = False   -- nothing beats an Ace
rankBeats Ace _ = True    -- an Ace beats anything else

The second equation is used only if the first equation doesn't match.

Page 18

Rank Beats Rank

rankBeats :: Rank -> Rank -> Bool
rankBeats _ Ace = False   -- nothing beats an Ace
rankBeats Ace _ = True    -- an Ace beats everything else
rankBeats _ King = False
rankBeats King _ = True
rankBeats _ Queen = False
rankBeats Queen _ = True
rankBeats _ Jack = False
rankBeats Jack _ = True

Page 19

Rank Beats Rank

rankBeats :: Rank -> Rank -> Bool
rankBeats _ Ace = False   -- nothing beats an Ace
rankBeats Ace _ = True    -- an Ace beats everything else
rankBeats _ King = False
rankBeats King _ = True
rankBeats _ Queen = False
rankBeats Queen _ = True
rankBeats _ Jack = False
rankBeats Jack _ = True
rankBeats (Numeric m) (Numeric n) = m > n

Page 20

Examples

rankBeats Jack (Numeric 7) True rankBeats (Numeric 10) Queen False

Page 21

Alternative solution

data Rank = Numeric Int | Jack | Queen | King | Ace
            deriving (Eq,Ord,Show)

rankBeats :: Rank -> Rank -> Bool
rankBeats r1 r2 = r1>r2

The ordering we want can often be obtained by using deriving Ord.
- Put the alternatives in the data definition in the right order!

Page 22

Alternative Rank type

```
Numeric n 
```
is a valid rank only if
```
n
```
is in
```
[2..10]
```
, but nothing stops us from creating values like
```
Numeric 0 
```
or
```
Numeric 35
```
. Consider this alternative type:

data Rank = N2 | N3 | N4 | N5 | N6 | N7 | N8 | N9 | N10
          | Jack | Queen | King | Ace
          deriving (Eq,Ord,Show,Enum)

Two advantages: it's junk-free. It is an enumeration type.
fromEnum N2 0 [N9 .. Ace] [N9,N10,Jack,Queen,King,Ace]
Disadvantages?

Page 23

Modelling a Card

A Card has both a Rank and a Suit

data Card = Card Rank Suit
            deriving Show

Functions to inspect the rank and suit of a card:

rank :: Card -> Rank
rank (Card r s) = r

suit :: Card -> Suit
suit (Card r s) = s

Page 24

When does one card beat another card?

When both cards have the same suit and the rank is higher:

cardBeats :: Card -> Card -> Bool
cardBeats (Card r1 s1) (Card r2 s2) = s1==s2 && rankBeats r1 r2

Need equality tests for the Suit type

data Suit = Spades | Hearts | Diamonds | Clubs
            deriving (Eq,Show)

Page 25

Alternative implementations of cardBeats

As before:

cardBeats :: Card -> Card -> Bool
cardBeats (Card r1 s1) (Card r2 s2) = s1==s2 && rankBeats r1 r2

Alternative:

cardBeats :: Card -> Card -> Bool
cardBeats card1 card2 = suit card1 == suit card2
                        && rankBeats (rank card1) (rank card2)

Which do you prefer?

Page 26

Modelling a Hand of Cards

A hand may contain any number of cards, from zero and up!
A natural choice is to use a list:
- ```
type Hand = [Card]
```
- This means that
```
Hand
```
  is just another name for the type
```
[Card]
```
  .

Page 27

When can a hand beat a card?

We need to find at least one card in the hand that can beat the other card

handBeats :: Hand -> Card -> Bool
handBeats hand card = betterCards hand card /= []

betterCards :: Hand -> Card -> [Card]
betterCards hand card = [ c | c<-hand, cardBeats c card ]

Page 28

Larger example: which card to play?

Given a card to beat and a hand
- Choose a card that can beat the card to beat, if possible.
  - Choose the lowest card that beats the card to beat.
- If you can follow suit, you must do that.
  - Choose the lowest card of the same suit.
- Otherwise, choose the lowest card
- ```
chooseCard :: Card -> Hand -> Card
```

Page 29

Which card to play?

chooseCard :: Card -> Hand -> Card
chooseCard beat hand
  | handBeats hand beat       = lowestCard (betterCards hand beat)
  | haveSuit hand (suit beat) = lowestCard (sameSuit hand (suit beat))
  | otherwise                 = lowestCard hand

Additional helper functions:

haveSuit    :: Hand -> Suit -> Bool
lowestCard  :: Hand -> Card
sameSuit    :: Hand -> Suit -> Hand

Page 30

Summary

Data modelling using data types
- Enumeration types (like
```
Suit
```
  )
  - All the values are atomic constants
- Examples of structured data (like
```
Rank
```
  and
```
Card
```
  )
  - The values have some internal structure
  - Pattern matching can be used to access the parts
Some more examples of lists and list comprehensions
- Processing a list with a recursive function