conditionals

So far, we have not seen ways of building functions outside of composing already defined operator. In this note, we introduce the constructs of haskell that allow for branching. There will be the standard if/then/else construct, and an idiomatic way of handling boolean conditions with what are called guards. But an arguably more important notion will be pattern matching, which allows to define to define a function by “inspecting the shape of the argument”.

Conditional expressions

In Haskell, we can use an if then else construct which generally has the following shape.

where boolean is an expression of type Bool and expr₁ and expr₂ have the same type, say A. This results in an overall expression of type A. Let us give a couple simple examples


integersFromToZero :: Int -> [Int]
integersFromToZero n = if n >= 0 then
                        [0 .. n-1]
                       else
                        [n+1 .. 0]

fizzBuzz :: (Integral a, Show a) => a -> String
fizzBuzz x = let divisibleBy n m = mod n m == 0 in
              if 3 `divisibleBy` x then
               if 5 `divisibleBy` x then
                 "fizzbuzz"
               else
                 "fizz"
              else if 5 `divisibleBy` x then
                     "buzz"
                   else
                     show x

-- the following is not an example of good style, but might be instructive as
-- an example of a valid definition.

greetings :: Bool -> Bool -> String
greetings a b = (if a then "Hi " else "Hello") ++
                " " ++
                if b then "friend" else "stranger"

someIncorrectCode x = if x == 0 then
                       "78"
                      else 78

Note also that something that is not allowed is having an if/then, but no else branches, as in

someIncorrectCode2 x = if x /= 0 then
                         x

If you do this, you will have a syntax error, possibly pointing to the next non-empty line of your program.

Guards

If you have an if/then/else at the toplevel of your expression, there is another idiomatic piece of syntax you might want to employ called guards. The syntax for a definition using a guard is the following

that should be read as “in case conditioni is true, then fnName args is defined to be bodyi”. We can reformulate the first two examples using guards as follows:


integersFromToZeroG :: Int -> [Int]
integersFromToZeroG n | n >= 0 = [0 .. n-1]
                      | otherwise = [n+1 .. 0]

divisibleBy :: Integral a => a -> a -> Bool
n `divisibleBy` m = mod n m == 0

fizzBuzzG :: Int -> String
fizzBuzzG x | 3 `divisibleBy` x = if 5 `divisibleBy` x then
                                    "fizzbuzz"
                                  else
                                    "fizz"
            | 5 `divisibleBy` x = "buzz"
            | otherwise         = show x

Another thing to note is that the first available line is taken as the definition, as is probably obvious from how the “otherwise” cases are laid out.

Unlike with if/then/else, there is no obligation of coverage of all cases with guards. Here is an example


takeVariant :: [Int] -> [Int]
takeVariant xs | head xs >= 0 = take (head xs) (tail xs)
               | null xs      = []

Pattern-matching

Finally, there is another, more primitive idiom to define functions by cases. The idea is that, in a function declaration

fnName arg₁ arg₂ ... | condition = body

each of arg₁ can be replaced by a pattern that describes the shape of an argument. We will later see how and why this is the most primitive way of doing a conditional in Haskell, but we need to see how to do so in a few particular cases:

For our first example, we can give a couple of examples where the pattern is a constant.


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


incrIfNZero :: Int -> Int 
incrIfNZero 0 = 0
incrIfNZero n = n + 1

Note that the order of the cases matters, much like with guards. The following two examples illustrate that

Note that in some cases, the branching allowed by the pattern-matching means you do not need to record some function arguments to know what is the output. In that case, one may replace a variable by an underscore to indicate “there is an argument, but I don’t even care to give it a name”. Here is an example of the logical function corresponding to implication.



impl :: Bool -> Bool -> Bool
impl False _ = True
impl _     b = b

Now, pattern-matching is especially powerful with structured type constructors like tupling and lists. Let us start with tupling. Besides constants, one can go a step further with tupling: we can start describing the shape of the tuple and give variable names to the components. Here is an example.


sumTriple :: Num a => (a, a, a) -> a
sumTriple (x, y, z) = x + y + z

Here we gave the names x y and z to the components of a single argument. This is true for triples of arbitrary size. It is also possible to nest patterns and actually analyze nested tuples easily.


assoc :: ((a, b), c) -> (a, (b, c))
assoc ((x, y), z) = (x, (y, z))

In patterns, one can only use each variables once; if you want to check equality of parts of arguments like in the following example, you have to use conditionals or guards:


addDistincts :: (Eq a, Num a) => (a, a) -> a
addDistincts (x, y) | x == y    = x
                    | otherwise = x + y

The reason we can do such pattern-matching is because, from the point of view of the haskell runtime, every fully evaluated thing of a tuple type must have shape (-, -) and (- , -) is a special basic construcor of the tuple types.

There is something similar going on with lists. In that case, there are two primitive list constructors that can be pattern-matched against: the empty list [] and the cons operator (:)


takeVariant2 :: [Int] -> [Int]
takeVariant2 [] = [21]
takeVariant2 (x : xs) = take x xs

Note that the parentheses around the list patterns are necessary (otherwise the compiler would try to parse x as an argument and would run into a syntax error when seeing the infix operator : in the middle fo the left-hand side)

In fact the basic function head and tail are defined using pattern-matching in the prelude (note that definitions with pattern-matching need not to cover all arguments and still be legal).


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

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

Much like with tuples, list patterns can be nested. Furthermore (and this is a special syntax for lists), one may use a syntax with brackets to match against list of fixed length.


addListOfSizeFiveOnly :: Num a => [a] -> a
addListOfSizeFiveOnly [x,y,z,t,u] = x + y + z + t + u
addListOfSizeFiveOnly _           = 0

firstTwoEqual :: Eq a => [a] -> Bool
firstTwoEqual (x : y : _)  = x == y
firstTwoEqual _            = False

someFunction :: [([a], [a])] -> [([a],[a])]
someFunction (([x,y], z) : xs)   = ([x], y : z) : xs
someFunction (([], t : ys) : xs) = ([t], ys) : xs
someFunction _                   = []

One can also do pattern-matching, as well as guards, in definitions in where clauses and let-ins


someOtherFunction :: (Num a, Ord a) => [a] -> a
someOtherFunction xs = let f (x : _) | x > 0 = x
                           f []      = 0 in
                        g (f xs)
                       where g 0 = 2
                             g x = 2 - x

Finally, there is also a way to do a patter matching in the middle of a function using a construct called case. You can look up the syntax online, but be careful if you use it as it is sensitive to indentation, much like where clauses, so it’s easy to make mistakes that lead to mysterious syntax errors.


someDefinition :: [Int] -> [Char]
someDefinition xs = "abc" ++ case takeVariant xs of
                               [] -> "cba"
                               x : xs -> show x 

someOtherDefinition :: [Int] -> Int
someOtherDefinition xs = case takeVariant2 (xs ++ [2 .. 5]) of
                           y : z : ys | y > z     -> y
                                      | otherwise -> z
                           []                     -> 2