Six ways to match patterns in Haskell
Pattern matching in Haskell involves three basic patterns and three compound patterns. Every function definition can be seen as some combination of these six patterns.
Match exact value
This is the simplest form with pattern as a value that is matched against the argument directly. For example, to write an
|| function, we can match the direct boolean values enumerating all four cases explicitly:
(||) :: Bool -> Bool -> Bool False || False = False False || True = True True || False = True True || True = True
Semantically, the patterns are matched from top to bottom, and whichever pattern matches first, the corresponding expression is evaluated and becomes the result of the function.
Match any value
The wildcard pattern to match any value is accomplished by using
_. For example, to write the above function more concisely, we can rewrite using wildcard pattern as:
(||) :: Bool -> Bool -> Bool False || False = False _ || _ = True
That is, the result is false only if both arguments are False. For all other cases (
_), the result is True.
This is like the wildcard pattern in the sense that any value is matched. In addition however, the matched value gets bound to the variable used in the pattern. This variable can be used in the corresponding expression. For example, the above function can also be defined as follows:
(||) :: Bool -> Bool -> Bool False || b = b True || _ = True
In the first pattern, we bind the second argument to a variable b. This value is used in the expression. So we say that if the first argument is False, the second argument is bound to a variable, which is the result of that pattern. In the second pattern, we use the exact value pattern (True) and wildcard. We evaluate this pattern to True.
Compound patterns are used to match tuples or lists. Here, we still make use of basic patterns, but inside lists and tuples.
Tuple patterns are matched against tuples of same arity and corresponding patterns are matched against tuple components in same order. For example,
(p1,p2,p3) will match any tuple with three components. First component is matched against p1, second against p2 and third against p3. In the example below, we use a tuple pattern to create a list containing second component from a list of pairs:
seconds :: [(a,b)] -> [b] seconds ps = [y | (_,y) <- ps]
Note that this tuple pattern contains two basic patterns - wildcard and variable binding.
List pattern is used to match lists of finite length. For example,
[p1,p2] will match any list of length 2. First element is matched against p1 and second against p2. In the following example, we match any three character string:
threeChars :: String -> Bool threeChars [_,_,_] = True threeChars _ = False
Note that this list contain one basic pattern for all three patterns - wildcard.
Cons pattern is used to match lists of any length. For example, to match a string of any length that begins with ‘a’, we can define the following function:
startsWith_a :: String -> Bool startsWith_a ('a':_) = True startsWith_a _ = False
Note that the cons pattern is enclosed inside parenthesis. In the first pattern, we match the head with ‘a’ and throw the tail away using wildcard. In the second pattern, we use wildcard to match every other string and evaluate that to False.