Guards – Haskell

Haskell provides several features that allow for elegant and expressive code. One such feature is guards, which give you a powerful way to express complex conditional logic in a clean and readable manner. Guards allow you to write functions that branch based on different conditions, offering a clearer alternative to multiple if-else statements.

In this blog, we’ll dive into what guards are, how to use them, and why they can make your Haskell code more concise and readable.

What Are Guards in Haskell?

In Haskell, guards are a way of expressing conditional logic, typically used in function definitions. They allow you to define multiple conditions, and Haskell will evaluate each condition in order until it finds one that is True. Once a True condition is found, the corresponding expression is executed.

The syntax for guards is very straightforward:

• You use the pipe character (|) to introduce a condition.
• After the condition, you specify the result for that case.
• You can have multiple guards for a single function or case, and Haskell will evaluate them from top to bottom.

Here’s the general syntax for a function with guards:

functionName parameters
  | condition1 = result1
  | condition2 = result2
  | otherwise  = defaultResult

• condition1, condition2, etc.: These are boolean expressions that get evaluated in order.
• result1, result2, etc.: These are the values returned if the corresponding condition is True.
• otherwise: A catch-all condition that always evaluates to True (it’s equivalent to writing True). It typically handles the default or fallback case.

func grade(score: Int) -> String {
    switch score {
    case 90...:
        return "A"
    case 80...89:
        return "B"
    case 70...79:
        return "C"
    case 60...69:
        return "D"
    default:
        return "F"
    }
}

In summary, guards in Haskell are similar to:

• if-else chains in languages like Python, Java, and C++.
• switch or case statements with ranges in languages like Swift or C.
• Pattern matching with conditions in languages like Scala and Erlang.
• Ternary operators in languages like JavaScript or Python (though guards are more powerful and readable).

Guards in Haskell offer a clean, declarative approach to handling multiple conditions, making them particularly useful for functional programming.

Example: Defining a Function with Guards

Let’s look at an example where we define a function to categorize a person’s age:

ageGroup :: Int -> String
ageGroup age
  | age <= 12  = "Child"
  | age <= 19  = "Teenager"
  | age <= 64  = "Adult"
  | otherwise  = "Senior"

How It Works:

• The function ageGroup takes an age (an integer) as input.
• The guards (age <= 12, age <= 19, etc.) define different conditions for different age groups.
• Haskell evaluates the guards in order until it finds a True condition. If no earlier guard matches, the otherwise guard (which is always True) acts as a fallback.

Example Usage:

ageGroup 10   -- Result: "Child"
ageGroup 17   -- Result: "Teenager"
ageGroup 45   -- Result: "Adult"
ageGroup 70   -- Result: "Senior"

The otherwise Guard

The otherwise keyword is simply a synonym for True, and it is typically used as the last guard to catch any unmatched cases. It’s not strictly necessary to use otherwise—you can replace it with True or any condition you see fit—but it’s widely used because it makes code more readable and explicit.

Here’s an example without otherwise:

temperatureStatus :: Int -> String
temperatureStatus temp
  | temp < 0    = "Freezing"
  | temp < 20   = "Cold"
  | temp < 30   = "Warm"
  | True        = "Hot"  -- Equivalent to using otherwise

Example: Calculating a Grade with Guards

Let’s define a function that assigns a letter grade based on a percentage score:

grade :: Int -> String
grade score
  | score >= 90 = "A"
  | score >= 80 = "B"
  | score >= 70 = "C"
  | score >= 60 = "D"
  | otherwise   = "F"

Explanation:

• The grade function uses multiple guards to match a score with a corresponding letter grade.
• It evaluates conditions in descending order, ensuring that the highest scores are handled first.
• If none of the conditions match, the otherwise guard gives an “F” grade for scores below 60.

Example Usage:

grade 95   -- Result: "A"
grade 82   -- Result: "B"
grade 58   -- Result: "F"

Combining Guards with Pattern Matching

Guards can be combined with pattern matching to create even more expressive and powerful function definitions. For example, let’s write a function that checks if a number is a prime number using guards and pattern matching:

isPrime :: Int -> Bool
isPrime 1 = False
isPrime 2 = True
isPrime n
  | n < 1          = False
  | any (\x -> n `mod` x == 0) [2..n-1] = False
  | otherwise      = True

Explanation:

• The first two patterns handle the base cases: 1 is not a prime, and 2 is a prime.
• For any other number n, the guards check:
  • If n < 1, it’s not a prime.
  • If n is divisible by any number from 2 to n-1, it’s not a prime.
  • The otherwise guard returns True for numbers that pass the test, meaning they are prime.

Example Usage:

isPrime 1    -- Result: False
isPrime 2    -- Result: True
isPrime 7    -- Result: True
isPrime 10   -- Result: False

Guard vs. if-else: Why Use Guards?

You might wonder, why use guards when you can achieve similar results with if-else expressions? While if-else works, guards provide a cleaner and more readable approach when handling multiple conditions. Here’s why guards are often preferred:

1. Clarity: Guards clearly separate different conditions, making it easier to follow complex logic.
2. Modularity: Each guard is evaluated independently, which keeps your code modular and easier to extend.
3. Readability: Guards provide a more natural syntax for handling multiple branches of logic, compared to nested if-else expressions.

if-else vs. Guards:

Here’s an equivalent if-else version of the ageGroup function:

ageGroup :: Int -> String
ageGroup age =
  if age <= 12 then "Child"
  else if age <= 19 then "Teenager"
  else if age <= 64 then "Adult"
  else "Senior"

Both versions are correct, but the one using guards is generally easier to read, especially when dealing with many conditions.

Using Guards in where Clauses

Haskell also allows you to use guards in combination with where clauses to define local variables or helper functions.

Example: BMI Calculator with where Clause

bmiCategory :: Double -> Double -> String
bmiCategory weight height
  | bmi <= 18.5 = "Underweight"
  | bmi <= 24.9 = "Normal weight"
  | bmi <= 29.9 = "Overweight"
  | otherwise   = "Obese"
  where bmi = weight / (height ^ 2)

Explanation:

• The bmiCategory function uses guards to categorize BMI values.
• The bmi value is calculated once in the where clause and reused in the guards, making the function more efficient and readable.

Example Usage:

bmiCategory 70 1.75   -- Result: "Normal weight"
bmiCategory 90 1.75   -- Result: "Overweight"

Conclusion

Guards in Haskell provide an elegant and readable way to handle multiple conditional branches. They allow you to write functions that are cleaner and easier to understand than equivalent if-else expressions. Whether you’re categorizing data, calculating results based on conditions, or using pattern matching, guards give you a flexible and powerful tool to express conditional logic in a clear and declarative manner.

By mastering guards, you’ll be able to write more concise and expressive Haskell code, making your programs easier to maintain and extend. So next time you find yourself writing multiple if-else expressions, consider switching to guards for a more Haskell-idiomatic approach!

💡 Helpful References

Learn You a Haskell - Syntax in Functions
https://learnyouahaskell.github.io/syntax-in-functions.html

Frequently Asked Questions (FAQs) About Guards in Haskell:

1. What are guards in Haskell?

Guards in Haskell are a way to express conditional logic within function definitions. They allow you to define multiple conditions for a function, and Haskell evaluates them from top to bottom. When it finds a condition that is True, it executes the corresponding expression.

2. How do I write a guard in Haskell?

You write a guard using the pipe (|) character followed by a condition. Here’s the basic syntax:

functionName parameters
  | condition1 = result1
  | condition2 = result2
  | otherwise  = defaultResult

• Each condition is a boolean expression.
• Guards are evaluated in order, and the first True condition returns its corresponding result.
• The otherwise keyword (equivalent to True) acts as a fallback guard.

3. How is otherwise used in guards?

otherwise is a synonym for True. It is typically used as the last guard to handle all remaining cases that weren’t matched by earlier guards. It acts as a default case in pattern matching.

Example:

bmiCategory :: Double -> String
bmiCategory bmi
  | bmi <= 18.5 = "Underweight"
  | bmi <= 24.9 = "Normal"
  | otherwise   = "Overweight"

If none of the earlier conditions match, otherwise ensures the function handles any input.

4. What’s the difference between guards and if-else in Haskell?

Both guards and if-else are used for conditional logic, but guards provide a cleaner, more readable syntax when you have multiple conditions to evaluate. if-else is better suited for simple, single-branch conditions, while guards make complex branching easier to follow.

Example of guards:

grade :: Int -> String
grade score
  | score >= 90 = "A"
  | score >= 80 = "B"
  | otherwise   = "F"

Equivalent if-else:

grade :: Int -> String
grade score =
  if score >= 90 then "A"
  else if score >= 80 then "B"
  else "F"

5. Can guards be combined with pattern matching?

Yes, guards can be used in combination with pattern matching to make code more expressive. For example, you can pattern match on the structure of data and use guards to evaluate conditions based on the matched values.

Example:

describeList :: [Int] -> String
describeList [] = "Empty list"
describeList (x:xs)
  | x > 0     = "Head is positive"
  | x == 0    = "Head is zero"
  | otherwise = "Head is negative"

6. Can I use multiple guards in a function?

Yes, you can use as many guards as you need in a function. Haskell will evaluate them from top to bottom, and the first condition that evaluates to True will be executed.

Example:

temperatureStatus :: Int -> String
temperatureStatus temp
  | temp < 0   = "Freezing"
  | temp < 15  = "Cold"
  | temp < 25  = "Warm"
  | otherwise  = "Hot"

7. What happens if none of the guards are True and there’s no otherwise?

If none of the guards evaluate to True and there is no otherwise case, the function will cause a runtime error. This is why it’s a good practice to always include an otherwise or handle all possible cases explicitly.

Example (with missing otherwise):

grade :: Int -> String
grade score
  | score >= 90 = "A"
  | score >= 80 = "B"

Calling grade 70 will cause a runtime error since no guard matches the input and there’s no default case.

8. Are guards more efficient than if-else?

Guards and if-else generally compile to similar code, so the performance difference is negligible. The advantage of guards is more about readability and maintainability than efficiency. Guards make the structure of conditional logic clearer when handling multiple conditions.

9. Can I use where or let with guards?

Yes, you can use where or let clauses with guards to define local variables or helper functions that make the code cleaner.

Example with where:

bmiCategory :: Double -> Double -> String
bmiCategory weight height
  | bmi <= 18.5 = "Underweight"
  | bmi <= 24.9 = "Normal weight"
  | bmi <= 29.9 = "Overweight"
  | otherwise   = "Obese"
  where bmi = weight / (height ^ 2)

10. Can I use guards with non-numeric types?

Yes, guards can be used with any data type, as long as the condition returns a Bool. You can use guards with strings, booleans, lists, and any other types in Haskell.

Example with a string:

greet :: String -> String
greet name
  | name == "Alice" = "Hello, Alice!"
  | name == "Bob"   = "Hi, Bob!"
  | otherwise       = "Hey there!"

11. What are Guards similar to in other popular programming languages?

In summary, guards in Haskell are similar to:

• if-else chains in languages like Python, Java, and C++.
• switch or case statements with ranges in languages like Swift or C.
• Pattern matching with conditions in languages like Scala and Erlang.
• Ternary operators in languages like JavaScript or Python (though guards are more powerful and readable).

Guards in Haskell offer a clean, declarative approach to handling multiple conditions, making them particularly useful for functional programming. Their closest analog in most imperative languages would be if-else chains or switch-case statements with conditions.