Modelling & Datatypes

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 strings, but there is often better alternatives.
• Today's lecture: we look at how to model data by defining new types in Haskell.

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.

Live Demo

• Source code: DataTypes.hs

Showing Values

• Spades <interactive>:3:1: error: • No instance for (Show Suit) arising from a use of ‘print’ • In a stmt of an interactive GHCi command: print it :i print print :: Show a => a -> IO () -- Defined in ‘System.IO’
• Fix

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

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

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.

Alternative notation for case analysis

• colour :: Suit -> Colour
  colour suit =
      case suit of
        Spades   -> Black
        Hearts   -> Red
        Diamonds -> Red
        Clubs    -> Black

• Less repetitive...
• Useful if you need to do case analysis on values other than the function arguments, e.g.

  • f suit = case colour suit of
               Red   -> (...)
               Black -> (...)
    

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

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

    .

Rank Beats Rank

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

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.

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

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

Examples

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

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!

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?

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

A useful shortcut

• data Card = Card {rank::Rank, suit:: Suit}
              deriving Show
  
  example_card_1 = Card Ace Spades
  example_card_2 = Card {rank=King, suit=Hearts}
  

• Defines the same data type and the functions rank and suit at the same time.
• Also affects how values are shown.

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)
  

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?

Modelling a Hand of Cards 1

• A hand may contain any number of cards, from zero and up!
• A natural choice is to use a list:

  • type Hand = [Card]
    

• For illustrative purposes, we will define our own type instead, something like

  • data Hand = Hand Card {-...-} Card

  • where the idea is that

    {-...-}

      means that an arbitrary number of cards can be given.
    • But this is not valid Haskell code!

Modelling a Hand of Cards

Break it down into two cases

• An empty hand
• Adding one more card to an existing hand

• data Hand = Empty | Add Card Hand
              deriving Show

  • A recursive type!

When can a hand beat a card?

• An empty hand beats nothing
• A non-empty hand can beat a card if the first card can, or if the rest of the hand can!

• handBeats :: Hand -> Card -> Bool
  handBeats Empty card = False
  handBeats (Add c h) card = cardBeats c card || handBeats h card

  • A recursive function!

Recap

• Modelling the problem using datatypes with components
• Using recursive datatypes to model things of varying size
• Using recursive functions to manipulate recursive data types