Datatypes and lists

(Pattern matching, recursion)

Datatypes: recap

From last week:

data Suit = Spades | Hearts | Diamonds | Clubs

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

data Card = Card Rank Suit

type Hand = [Card]

A comment on Haskell syntax

What does this mean?
- ```
data Card = Card Rank Suit
```

It means that a card is created by combining a rank and a suit:

```
Card
```
::
```
Rank -> Suit -> Card
```

example_card :: Card
example_card = Card Ace Spades

This is essentially what is know as a cartesian product in discrete math:
- ```
Card
```
  =
```
Rank
```
  ×
```
Suit
```
- c = ⟨
```
Ace
```
  ,
```
Spades
```
  ⟩

A comment on Haskell syntax

Alternativ syntax

Instead of…

data Card = Card Rank Suit

rank :: Card -> Rank
rank (Card rank suit) = rank

suit :: Card -> Suit
suit (Card rank suit) = suit

…Haskell allows you to write

data Card = Card {rank::Rank, suit::Suit}

Pattern matching

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

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

Functions on the values of a datatype are usually defined by pattern matching.
Functions will often have one equation for each alternative in the data type.
Sometimes alternatives can be combined by using variable or wildcard (don't-care) patterns.
The compiler knows what the alternatives are and can generate a warning if alternatives are missing in a function definition. (-Wincomple-patterns).

Live demo

Continuing from last time
Source code: DataTypes.hs

Lists: recap

Haskell has a predefined type and special syntax for lists.

Lists contain 0, 1, 2, or more values.

[]

,

[3]

,

["Haskell","JavaScript","C","Python"]

The order matters:
```
[1,2,3] /= [3,2,1]
```
All values in a list have the same type
- ```
[1,3,True,"Python"]
```
  causes a type error.
The list types indicates the type of the values in the list:
- ```
[Integer]
```
```
[String]
```
```
[[Integer]]
```

Strings and type synonyms

```
type String = [Char]
```
The type keyword introduces a type synonym, i.e. another name for an existing type.

A string is a list of characters:

"Haskell" == ['H','a','s','k','e','l','l']

Polymorphic list functions and their types

Many functions on lists are "generic": the don't need to know anything about the values in the lists to do their work. For example:

null    :: [a]   -> Bool
length  :: [a]   -> Int
concat  :: [[a]] -> [a]
reverse :: [a]   -> [a]

(++)    :: [a] -> [a] -> [a]
take    :: Int -> [a] -> [a]
zip     :: [a] -> [b] -> [(a,b)]

List functions for specific types

There are also functions for specific types of lists. for example:

and, or          :: [Bool]   -> Bool
words, lines     :: String   -> [String]
unwords, unlines :: [String] -> String

Overloaded list functions

sum, product     :: Num a => [a] -> a
elem             :: Eq a  =>  a  -> [a] -> Bool
sort             :: Ord a => [a] -> [a]

To use
```
sort
```
, import Data.List

Live Demo

Let's look at some illustrative examples...

null, length, sum,
reverse,
insert, iSort
Source code: Lists1.hs

Summary

We have seen

Datatypes
Partial functions vs total functions
Pattern matching
Lists: what's hiding behind the […,…,…] notation
Recursive functions on lists
(Some things were moved to the next lecture)