Pattern Matching

not :: Bool -> Bool
not True  = False
not False = True

Notice that the not function has two rules:

• The first rule says that if the parameter is True, then the function returns False.
• The second rule says that if the parameter is False, then the function returns True.

When you run a function, only one rule can run. Haskell runs the first matching rule.

• Function parameters are not variables but patterns.
• One pattern may match an expression.
• The first matching alternative is selected at evaluation.

Types of Patterns

A pattern may be:

• a variable: x, xs, y, a, foobar… These names match any value, and can be used in the rule’s body.
• a wildcard: _ This symbol matches any value, and cannot be used in the rule’s body. It is a “don’t care” value.
• a type-specific pattern: True, 0, (a, b), "hello"… Only values matching the given pattern are accepted.

Incomplete Patterns

Usually, a function should match all possible values. For example, in the not function above, the possible values are True and False, and we have a rule for both. What happens if call the function with a value for which there is no rule?

addOne :: Int -> Int
addOne 0 = 1
addOne 1 = 2
addOne 2 = 3

Try calling addOne with the parameter 5.

How can we fix the above function?

Prelude.&&

Here is a possible definition of the logical AND operation:

(&&) :: Bool -> Bool -> Bool
True  && True  = True
True  && False = False
False && True  = False
False && False = False

-- True  && True  = True
-- _     && _     = False

-- True  && x     = x
-- _     && _     = False

Exercise: (Prelude.||) [*]

Redefine the (||) operator.

(||) :: Bool -> Bool -> Bool

-- import Prelude hiding ((||), ...)

Exercise: Exclusive OR

Define the exclusive OR function.

xor :: Bool -> Bool -> Bool

Patterns for Pairs: Prelude.fst

Pattern for matching pairs: (x, y).

For example:

fst (a, b) = a
snd (a, b) = b

Usage:

Exercise: Swapping Elements [*]

Swap two elements of a pair. Use pattern matching on a tuple.

swap :: (a, b) -> (b, a)

Exercise: Reflection in the X Axis

Reflect a point in the X axis.

reflectX :: Num a => (a, a) -> (a, a)

Exercise: Scaling in the Origin

Let scale' t be a scaling by t in the origin. The magnitude of the point will increase by the given value.

scale' :: Num a => a -> (a, a) -> (a, a)

Exercise: Point Reflection

Reflect a point around another point. The first point acts as an origin; the second point is reflected to its opposite side. See the examples below.

reflectP :: Num a => (a, a) -> (a, a) -> (a, a)

Exercise: Distance [*]

Calculate the distance of two points.

distance :: Floating t => (t, t) -> (t, t) -> t

Patterns for Numbers, Characters, and Strings

Values can be used to match patterns in function parameters of different types. For example:

Integer: …, -2, -1, 0, 1, 2, …

Double: …, -2, -1, 0, 1, 2, …, 4.3, …

Char: 'x', '\n', …

String: "", "abc", …

Exercise: Modulo 3 Multiplication [*]

Define modulo 3 multiplication. This means that for every x and y between 0 and 3, this expression will be true:

x `mul3` y == (x * y) `mod` 3

Use pattern matching to achieve this. Do not use the mod function or multiplication operator in your solution!

mul3 :: Int -> Int -> Int

Exercise: Replace Line Break with Space

Define a function that replaces a line break with a space, and otherwise returns the same value. Recall that ‘’ is the character value for a newline.

replaceNewline :: Char -> Char

Exercise: Replace All Line Breaks with Spaces

Define a function that replaces all line breaks with spaces. Use replaceNewline.

replaceNewlines :: String -> String

Exercise: Swap “this” and “that” [*]

Define a function that replaces the words “this” and “that” and vice versa.

swapThisAndThat :: String -> String

Exercise: Swap All “this” and “that” [*]

Define a function that swaps all instances of “this” and “that”.

swapAllThisAndThat :: String -> String

Hint: Use the words and unwords functions.

Patterns for Lists

We have shown that we can match patterns for Strings, Ints, tuples, etc. We can also match lists. In particular, we can express requirements about the size of the list. Only a list matching the requirements will invoke the function’s rule:

Match any list: a Match an empty list: []
Match a list with exactly one item (“singleton”): [a]
Match a list with exactly two items: [a,b]
Match a list with exactly three items: [a,b,c]
Match a non-empty list: (a:b)

Note that when we use a pattern like [a,b], the name a refers to the first item in the list, and the name b refers to the second item in the list. When we use a pattern like (a:b), a refers to the first item in the list, and b refers to the rest of the list; therefore b will be a (possibly empty) list.

For example (functions from the Prelude):

null returns True when its parameter is an empty list.

null :: [a] -> Bool
null [] = True
null _  = False

head returns the first item of a list.

head :: [a] -> a
head (x:xs) = x

tail returns all items of a list except the first.

tail :: [a] -> [a]
tail (x:xs) = xs

Usage:

Exercise: Is A Singleton List? [*]

Define a function that tests the given list is a singleton one. Use pattern matching.

isSingleton :: [a] -> Bool

Exercise: Capitalize Initial Letter [*]

Convert the initial letter of an arbitrary word to uppercase.

toUpperFirst :: String -> String

Hint: use the function toUpper:

Exercise: Capitalize All Initial Letters

Convert the initial letter of every word in a string to uppercase.

toUpperFirsts :: String -> String

Hint: use your toUpperFirst function and words and unwords

Patterns in List Comprehensions

Patterns can be even employed in list comprehensions. Here is an intuitive example for this:

Exercise: Identical Words in a Text

Count the “a” words in a text.

countOfAs :: String -> Int

Exercise: Filter by Distance of Elements

Count pairs in a list where the distance between the components is greater than or equal to 2.

distantPairs :: [(Integer,Integer)] -> Int

Exercise: Every Fifth Element of a List

Take every fifth element of a list.

everyFifth :: [a] -> [a]

Hint: Use the zip function.