The Project | About Us | Contribute | Donations | License
HOME My courses Completed
◄ Previous
◄

Map, Filter, and Fold

Next ►
►

In this section, we will explore three fundamental higher-order functions in Haskell: map, filter, and fold. These functions are essential tools for functional programming and allow you to manipulate lists and other data structures in a concise and expressive manner.

Map

The map function applies a given function to each element of a list, producing a new list with the results.

Syntax

map :: (a -> b) -> [a] -> [b]

Example

-- Define a function to double a number
double :: Int -> Int
double x = x * 2

-- Use map to apply the double function to each element of the list
doubledList = map double [1, 2, 3, 4, 5]
-- Result: [2, 4, 6, 8, 10]

Explanation

  • double is a function that takes an integer and returns its double.
  • map double [1, 2, 3, 4, 5] applies the double function to each element of the list [1, 2, 3, 4, 5], resulting in [2, 4, 6, 8, 10].

Filter

The filter function takes a predicate (a function that returns a boolean) and a list, returning a new list containing only the elements that satisfy the predicate.

Syntax

filter :: (a -> Bool) -> [a] -> [a]

Example

-- Define a predicate to check if a number is even
isEven :: Int -> Bool
isEven x = x `mod` 2 == 0

-- Use filter to get only the even numbers from the list
evenList = filter isEven [1, 2, 3, 4, 5, 6]
-- Result: [2, 4, 6]

Explanation

  • isEven is a predicate function that checks if a number is even.
  • filter isEven [1, 2, 3, 4, 5, 6] filters the list [1, 2, 3, 4, 5, 6] to include only the even numbers, resulting in [2, 4, 6].

Fold

The fold function (also known as reduce in other languages) reduces a list to a single value by iteratively applying a binary function. There are two main types of fold: foldl (fold left) and foldr (fold right).

Syntax

foldl :: (b -> a -> b) -> b -> [a] -> b
foldr :: (a -> b -> b) -> b -> [a] -> b

Example: foldl

-- Define a function to add two numbers
add :: Int -> Int -> Int
add x y = x + y

-- Use foldl to sum the elements of the list
sumList = foldl add 0 [1, 2, 3, 4, 5]
-- Result: 15

Example: foldr

-- Define a function to concatenate two lists
concatLists :: [a] -> [a] -> [a]
concatLists x y = x ++ y

-- Use foldr to concatenate a list of lists
concatenatedList = foldr concatLists [] [[1, 2], [3, 4], [5]]
-- Result: [1, 2, 3, 4, 5]

Explanation

  • foldl add 0 [1, 2, 3, 4, 5] starts with the initial value 0 and iteratively applies the add function to accumulate the sum of the list, resulting in 15.
  • foldr concatLists [] [[1, 2], [3, 4], [5]] starts with the initial value [] and iteratively applies the concatLists function to concatenate the lists, resulting in [1, 2, 3, 4, 5].

Practical Exercises

Exercise 1: Using map

Write a function that takes a list of integers and returns a list of their squares.

squareList :: [Int] -> [Int]
squareList = map (\x -> x * x)

-- Test the function
main = print (squareList [1, 2, 3, 4, 5])
-- Expected output: [1, 4, 9, 16, 25]

Exercise 2: Using filter

Write a function that takes a list of integers and returns a list of numbers greater than 10.

greaterThanTen :: [Int] -> [Int]
greaterThanTen = filter (> 10)

-- Test the function
main = print (greaterThanTen [5, 12, 8, 20, 3])
-- Expected output: [12, 20]

Exercise 3: Using foldl

Write a function that takes a list of integers and returns their product.

productList :: [Int] -> Int
productList = foldl (*) 1

-- Test the function
main = print (productList [1, 2, 3, 4, 5])
-- Expected output: 120

Common Mistakes and Tips

  • Off-by-one errors: Ensure that your initial value in foldl and foldr is appropriate for the operation (e.g., 0 for sum, 1 for product).
  • Function application: Remember that map and filter take functions as arguments. Ensure the functions you pass are of the correct type.
  • List comprehension: Sometimes, list comprehensions can be more readable than map and filter. Use the approach that makes your code clearer.

Conclusion

In this section, we covered the map, filter, and fold functions in Haskell. These higher-order functions are powerful tools for manipulating lists and other data structures. By understanding and using these functions, you can write more concise and expressive Haskell code. In the next section, we will delve into list comprehensions, another powerful feature for working with lists in Haskell.

◄ Previous
◄
Next ►
►
The Project | About Us | Contribute | Donations | License
© Copyright 2024. All rights reserved