Haskell List Comprehensions | CodeSignal Learn

Haskell List Comprehensions | CodeSignal Learn

Introduction to List Comprehensions

Welcome to Unit 5 of our course! In the previous lessons, you learned how to work with lists and how to group different pieces of data using tuples . As you continue writing Haskell programs, you will often find that you need to create a new list based on the contents of an existing one. In this lesson, we will introduce a powerful concept called a list comprehension . If you have ever seen set-builder notation in a mathematics class, this idea will feel very familiar. A list comprehension provides a declarative way to create lists. This means that instead of writing out step-by-step instructions on exactly how to build the list, you simply describe what you want the final list to look like. It is a clean, readable syntax that allows you to transform and filter data seamlessly.

Transforming Data with Generators

A list comprehension is enclosed in square brackets [ ] and is split into two main parts by a vertical pipe | . The right side of the pipe defines where your data comes from, and the left side defines what the output will look like. Let us start with the right side, which is known as a generator . Haskell also supports range syntax: [1 .. 5] creates the list [1,2,3,4,5] . We can draw elements from this list one by one using a left-pointing arrow <- . Haskell [n | n <- [1 .. 5]] In the snippet above, n <- [1 .. 5] is the generator. You can read it as: "Draw elements from the list [1 .. 5] one by one, and name each element n ." The left side of the pipe is simply n, meaning our output is exactly what we drew from the source list. However, the real power of list comprehensions comes from modifying that output. Let us say we want a list of squared numbers instead. We can change the output expression on the left side to multiply n by itself. Haskell squares :: [Int] squares = [n * n | n <- [1 .. 5]] By changing the expression to n * n, we are instructing Haskell to compute the square for each element drawn by the generator. If you were to print the squares list, the output would be: text [1,4,9,16,25]

Filtering Data with Guards

Often, you do not want to transform every element from your source list. Instead, you might only be interested in the elements that meet a specific condition. In a list comprehension, you can achieve this by adding a guard . A guard is a simple true-or-false test placed at the end of the comprehension, separated from the generator by a comma. Let us start by simply drawing numbers from a slightly larger list — from 1 to 10. Haskell [n | n <- [1 .. 10]] Now, suppose we want to filter this list so that we only keep the even numbers. We can use the built-in Haskell function even, which evaluates to true if a number is even and false otherwise. We add this guard right after our generator. Haskell evens :: [Int] evens = [n | n <- [1 .. 10], even n] When Haskell evaluates this comprehension, it draws a number n from the list [1 .. 10] . Then, it checks the guard even n . If the guard is true, the number is passed to the output expression (which is just n in this case) and added to the new list. If the guard is false, the number is skipped. If you print the evens list, the output will be: text [2,4,6,8,10]

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

All Combinations with Multiple Generators

List comprehensions are not limited to a single generator. You can use multiple generators within the same comprehension by separating them with commas. When you do this, Haskell will combine every element from the first list with every element from the second list, effectively creating all possible combinations. Let us recall tuples from Unit 4, which allow us to group values together in parentheses ( ) . We can use multiple generators to create a list of paired tuples. We will draw x from [1, 2], draw y from [3, 4], and place (x, y) on the left side as the output expression. Haskell pairs :: [(Int, Int)] pairs = [(x, y) | x <- [1, 2], y <- [3, 4]] The evaluation happens exactly as if you were reading from left to right across the generators: for the first element x = 1, it runs through all possibilities for y (3, then 4). Then, it moves to the next x (2) and runs through all possibilities for y again. When you print the pairs list, you will see the full cross-product of the pairs: text [(1,3),(1,4),(2,3),(2,4)]

Summary and Next Steps

In this lesson, we explored the three core parts of a list comprehension: The output expression that shapes the final data. The generator(s) that draw elements from existing lists. The optional guards that filter which elements are kept. Here is the complete script containing everything we built step by step. We have also included a main function that uses print to display our three lists to the screen. Haskell squares :: [Int] squares = [n * n | n <- [1 .. 5]] evens :: [Int] evens = [n | n <- [1 .. 10], even n] pairs :: [(Int, Int)] pairs = [(x, y) | x <- [1, 2], y <- [3, 4]] main :: IO () main = do print squares print evens print pairs Running this full program produces the following output: text [1,4,9,16,25] [2,4,6,8,10] [(1,3),(1,4),(2,3),(2,4)] You are currently completing Unit 5 out of our 7 total units, and you are making excellent progress! Now that you have seen how compact and powerful list comprehensions can be, it is time for you to try writing them yourself. In the upcoming practice exercises, you will use the CodeSignal IDE to write your own list comprehensions, utilizing generators and guards to solve tasks efficiently.