Functions and Partial Application | CodeSignal Learn

Functions and Partial Application | CodeSignal Learn

Introduction: Functions as Values

Welcome to the first lesson of this course! In functional programming, we view code a bit differently than in other programming styles. Our core idea, and arguably the superpower of functional programming, is that functions are treated just like regular data. Think about how you use numbers or text in a program. You assign them to names and pass them as inputs to functions. In Haskell, you can do the exact same thing with functions themselves. You can take a function and pass it as an argument to another function. This concept makes our code highly reusable. Instead of writing a different piece of code for every minor task, we can write a single, general structure and pass in different functions to change how it behaves. This idea sets the stage for everything we will do later in the course.

Writing a Higher-Order Function (applyTwice)

A function that takes another function as an argument, or returns a function as its result, is called a " higher-order function ." Let's write our first higher-order function, called **applyTwice** . As the name suggests, this function will take an operation and apply it to a starting number twice. First, let's look at the type signature . In Haskell, we write type signatures to explain what kind of inputs a function expects and what it will return. Haskell applyTwice :: (Int -> Int) -> Int -> Int Notice the parentheses around (Int -> Int) . By wrapping Int -> Int in parentheses, we are telling Haskell: "The very first argument is not a number. It is a function that takes an integer and returns an integer." Without those parentheses, a type like Int -> Int -> Int -> Int would mean a curried function that takes an Int, then another Int, then another Int, and finally returns an Int . The parentheses make the first argument itself a function. Now, let's write the actual logic. Haskell applyTwice :: (Int -> Int) -> Int -> Int applyTwice f x = f (f x) Here, f represents our function, and x represents our starting value. In the code, we first apply f to x by writing f x . Because we want to apply it twice, we take that result and put it inside another call to f, creating f (f x) .

Passing Functions as Arguments

To use applyTwice, we need a simple function to pass into it. Let's define a straightforward helper function called **increment** that just adds 1 to a number. Haskell increment :: Int -> Int increment n = n + 1 Now, we can use applyTwice inside our main block. We will pass our increment function into applyTwice alongside the starting number 5 . Haskell applyTwice :: (Int -> Int) -> Int -> Int applyTwice f x = f (f x) increment :: Int -> Int increment n = n + 1 main :: IO () main = do print (applyTwice increment 5) When we run this code, applyTwice takes increment and 5 . It evaluates increment 5 to get 6, and then evaluates increment 6 to get 7 . Output: text 7 By simply passing its name, we proved that the increment function was successfully used as an input argument.

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

The Magic of Partial Application

There is another brilliant feature in Haskell that makes passing functions around incredibly convenient. It is called " partial application ." Partial application is the ability to give a function fewer arguments than it asks for. When you do this, Haskell does not produce an error; instead, it gives you a brand-new function waiting for the remaining arguments. Let's define a standard function that takes two arguments, add . Haskell add :: Int -> Int -> Int add a b = a + b This works because Haskell functions are curried by default. The arrows in a function type associate to the right, so this type: Haskell add :: Int -> Int -> Int is read as: Haskell add :: Int -> (Int -> Int) That means add takes one Int and returns a new function of type Int -> Int waiting for the second number. So when we provide only the first argument, 10, Haskell gives us that remaining one-argument function. Haskell addTen :: Int -> Int addTen = add 10 By supplying only 10, we created a brand-new, single-argument function called addTen . Whenever addTen is given a number, it will add 10 to it. Let's see this in action inside our main block. We can use addTen on its own, and we can also pass it into our applyTwice function from earlier! Haskell add :: Int -> Int -> Int add a b = a + b addTen :: Int -> Int addTen = add 10 main :: IO () main = do print (addTen 7) print (applyTwice addTen 0) In the first print statement, addTen 7 adds 10 to 7 . In the second print statement, applyTwice applies addTen to 0 two times (0 + 10 = 10, then 10 + 10 = 20). Output: text 1720 This shows how partial application lets you quickly build smaller, reusable functions out of larger ones.