Selecting Elements with Filter | CodeSignal Learn

Selecting Elements with Filter | CodeSignal Learn

Introduction to Filtering

Welcome to the third unit of our course! Imagine you have a large basket of apples, but you only want to bake a pie using the ripe ones. You would look at each apple, apply a rule ("Is it ripe?"), keep the ones that pass the test, and set aside the rest. In programming, we often need to do exactly this with our data. We want to keep specific elements from a list based on a certain rule, discard the rest, and preserve the original order of the items we kept. In Haskell, the perfect tool for this job is a built-in function called filter . Throughout this lesson, we will learn how to use filter to cleanly and easily select the exact data we need. Here is the type signature for filter : Haskell filter :: (a -> Bool) -> [a] -> [a] This tells us that filter takes a predicate — a function from an element type a to Bool — and a list of a values. It returns another list of the same element type a, because it keeps or discards existing items rather than changing them.

Quick Recall: map vs. filter

Before we look closely at filter, let us take a moment to remember what we learned in the previous lesson. You might recall that we used the map function to apply a change to every single item in a list. For example, map can take a list of numbers and transform it into a list of doubled numbers. map is all about transforming data. The filter function is different. It does not change or transform the items at all. Instead, it selects them. To make this selection, filter relies on what is called a predicate . A predicate is simply a function that asks a yes-or-no question. In Haskell terms, a predicate is a function that returns a Bool (either True or False). filter goes through a list item by item, applies the predicate function to each item, and keeps only the ones that return True .

Using filter with Built-in Predicates

Let us see filter in action. The filter function needs two arguments to do its job: a predicate (our True / False rule) and the list we want to search through. Haskell has several built-in predicates we can use right away. One of them is even, which takes a number and returns True if the number is even. Here is how we can combine filter and even to pick out the even numbers from a list of numbers 1 through 10 : Haskell evens :: [Int] evens = filter even [1 .. 10] In this code, we create a list of integers called evens . We tell filter to use the even rule on the list [1 .. 10] . It checks 1 (False, discard), then 2 (True, keep), then 3 (False, discard), and so on. If we were to print the evens list, the output would be: [2,4,6,8,10] Notice how the numbers we kept are still in their original order, and nothing has changed — we just dropped the odd numbers.

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

Filtering with Partial Application

Sometimes, the rule we want to use is not a simple built-in word like even . What if we want to keep only the numbers that are strictly greater than 5 ? In our very first lesson, we learned about partial application . We discovered that we can supply just one argument to a mathematical operator to create a brand-new, specialized function. We can use this exact concept to build a predicate for filter . By wrapping the greater-than sign and the number 5 in parentheses like this (> 5), we create a function that takes a number and returns True if it is greater than 5 . Let us use this partially applied function to filter a mixed list of numbers: Haskell bigEnough :: [Int] bigEnough = filter (> 5) [3, 8, 1, 9, 4, 7] Here, filter looks at each number. The number 3 is not greater than 5, so it is discarded. The number 8 is greater than 5, so it is kept. If we print the bigEnough list, the output is: [8,9,7] Using partial application makes it incredibly easy to build comparison rules on the fly!

Writing and Using Custom Named Predicates

There will be times when a built-in function or a quick partial application is not enough. You might have a specific, custom rule in mind. In these cases, you can write your own named predicate function. Let us write a function called isPositive that checks if a number is greater than zero. Haskell isPositive :: Int -> Bool isPositive n = n > 0 Notice the type signature: Int -> Bool . This clearly tells us that the function takes an integer and returns a Boolean . Because it returns a Bool, it is a perfect candidate to be used with filter . Now, we can pass our custom isPositive function directly into filter to clean up a list that contains negative numbers and a zero: Haskell isPositive :: Int -> Bool isPositive n = n > 0 positives :: [Int] positives = filter isPositive [-2, 5, -1, 8, 0] When filter runs, it checks -2 (False), 5 (True), -1 (False), 8 (True), and 0 (False, because 0 is not strictly greater than 0). If we print the positives list, the output is: [5,8]

Summary and Practice Prep

Excellent work! You now understand the key difference between our two main list-processing tools: use map when you want to transform every element, and use filter when you want to select specific elements. You have also seen how built-in functions, partial applications, and custom named functions can all serve as the True / False rules that drive filter . To bring it all together, here is what our complete code looks like when we combine our examples into one script and print them out: Haskell isPositive :: Int -> Bool isPositive n = n > 0 evens :: [Int] evens = filter even [1 .. 10] bigEnough :: [Int] bigEnough = filter (> 5) [3, 8, 1, 9, 4, 7] positives :: [Int] positives = filter isPositive [-2, 5, -1, 8, 0] main :: IO () main = do print evens print bigEnough print positives When run, this program outputs exactly what we expect: [2,4,6,8,10] [8,9,7] [5,8] You are now halfway through the course! You have built a solid foundation in functional programming concepts. Up next, you will jump into the CodeSignal IDE to practice these skills. You will write your own predicates and use filter to clean up different lists of data. Have fun with the exercises, and I will see you in the next unit!