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

Higher-Order Functions

Next ►
►

Higher-order functions are a fundamental concept in functional programming and Haskell. They are functions that can take other functions as arguments and/or return functions as results. This allows for a high degree of flexibility and abstraction in your code.

Key Concepts

  1. Definition: A higher-order function is a function that does at least one of the following:

    • Takes one or more functions as arguments.
    • Returns a function as its result.

  2. Examples of Higher-Order Functions:

    • map
    • filter
    • foldr and foldl

  3. Benefits:

    • Code reusability
    • Abstraction
    • Conciseness

Practical Examples

Example 1: map

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

-- Define a simple function that doubles a number
double :: Int -> Int
double x = x * 2

-- Use `map` to apply `double` to each element of a list
doubledList = map double [1, 2, 3, 4, 5]

-- Output: [2, 4, 6, 8, 10]

Example 2: 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.

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

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

-- Output: [2, 4, 6]

Example 3: foldr and foldl

The foldr (fold right) and foldl (fold left) functions reduce a list to a single value by applying a function recursively.

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

-- Use `foldr` to sum a list of numbers
sumRight = foldr add 0 [1, 2, 3, 4, 5]

-- Output: 15

-- Use `foldl` to sum a list of numbers
sumLeft = foldl add 0 [1, 2, 3, 4, 5]

-- Output: 15

Exercises

Exercise 1: Implement a Higher-Order Function

Write a higher-order function applyTwice that takes a function and a value, and applies the function to the value twice.

applyTwice :: (a -> a) -> a -> a
applyTwice f x = f (f x)

Test your function:

-- Define a simple function that adds 3 to a number
addThree :: Int -> Int
addThree x = x + 3

-- Use `applyTwice` to apply `addThree` twice to the number 10
result = applyTwice addThree 10

-- Output: 16

Exercise 2: Custom map Function

Implement your own version of the map function, called myMap.

myMap :: (a -> b) -> [a] -> [b]
myMap _ [] = []
myMap f (x:xs) = f x : myMap f xs

Test your function:

-- Define a simple function that squares a number
square :: Int -> Int
square x = x * x

-- Use `myMap` to apply `square` to each element of a list
squaredList = myMap square [1, 2, 3, 4, 5]

-- Output: [1, 4, 9, 16, 25]

Common Mistakes and Tips

  • Forgetting Base Cases: When implementing recursive higher-order functions, always ensure you handle the base case (e.g., an empty list).
  • Type Mismatches: Pay attention to the types of functions and arguments. Haskell's type system is strict, and type mismatches will result in compilation errors.
  • Function Composition: Use function composition (.) to combine multiple functions into a single function, making your code more concise.

Conclusion

Higher-order functions are a powerful feature in Haskell that allow for greater abstraction and code reuse. By understanding and utilizing functions like map, filter, and fold, you can write more concise and expressive code. Practice implementing and using higher-order functions to become more proficient in functional programming with Haskell.

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