Composing Functions into Pipelines

Introduction & Quick Recall: Building Data Pipelines

Welcome to the sixth and final unit of the course! Over the past few lessons, you have built a solid foundation in functional programming . We have explored how to treat functions as values and how to process lists using tools like *map*, *filter*, and *fold* (or *sum*). A major goal of functional programming is to treat your code like data pipelines (an assembly line). You take data and pass it through a series of small, well-named transformations to get your final result. Before we learn how to cleanly connect these steps, let us briefly recall how to define the small, simple functions that act as our building blocks. Haskell double :: Int -> Int double n = n * 2 increment :: Int -> Int increment n = n + 1 Here, we have two straightforward functions. One double s an integer, and the other increment s it. While they are useful on their own, the real power of functional programming comes from chaining small steps like these together. In this lesson, we will learn how to elegantly stitch these tools into a single, highly readable pipeline without getting lost in nested parentheses.

Combining Functions with the . Operator

If we want to double a number and then increment the result, we could write it out manually for every number. However, Haskell gives us a special tool to fuse two functions together into a brand-new function. This is done using function composition via the . (dot) operator . Here is the type signature for function composition: Haskell (.) :: (b -> c) -> (a -> b) -> a -> c The . operator represents mathematical function composition. It takes the output of one function and feeds it directly into the input of another. The right-hand function transforms an a into a b, and the left-hand function transforms that b into a c . Let us build a new function called doubleThenIncrement by combining our two simple functions. Haskell double :: Int -> Int double n = n * 2 increment :: Int -> Int increment n = n + 1 doubleThenIncrement :: Int -> Int doubleThenIncrement = increment . double When you look at increment . double, it is important to understand the execution flow. In Haskell function composition, the data moves from right to left : The data enters the rightmost function (double). The result of that calculation flows to the left into the next function (increment). By using the . operator, we did not have to write a new manual formula. We simply glued our existing, well-tested building blocks together to create doubleThenIncrement .

Join the 1M+ learners on CodeSignal

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

Assembling Complete Pipelines

Now we can bring both . and $ together to build complete, readable data-processing lines. We will use the . operator to glue our functions into a pipeline and the $ operator to cleanly apply that pipeline to our data.

Let us upgrade our sum of even numbers example. We can compose sum and filter even into a single, cohesive transformation using the dot, and then apply it to our list using the dollar sign.

Haskell

sumOfEvens :: Int
sumOfEvens = sum . filter even $ [1 .. 10]

Here is how the grouping works:

Haskell

sum . filter even $ [1 .. 10]
-- means:
(sum . filter even) [1 .. 10]
-- which means:
sum (filter even [1 .. 10])

Reading the pipeline from right to left: our list [1 .. 10] is passed to filter even, and the filtered result is passed to sum.

We can also use our composed functions with higher-order tools like map from our previous lessons. Let us bring everything together into a complete, runnable program with a main block to see our work in action.

Haskell

double :: Int -> Int
double n = n * 2

increment :: Int -> Int
increment n = n + 1

doubleThenIncrement :: Int -> Int
doubleThenIncrement = increment . double

sumOfEvens :: Int
sumOfEvens = sum . filter even $ [1 .. 10]

main :: IO ()
main = do
  print (doubleThenIncrement 5)
  print (map (increment . double) [1, 2, 3])
  print sumOfEvens

When we run this full code, the output will look like this:

text

11
[3,5,7]
30

Let us review what happened in our main block:

print (doubleThenIncrement 5) passed 5 into our custom pipeline. It doubled to 10, then incremented to 11.
print (map (increment . double) [1, 2, 3]) shows an inline composition. We composed our two small functions and used map to apply that pipeline to every number in the list. Note that we used parentheses here to group the composed function together so map knows exactly what transformation to apply.
print sumOfEvens outputted 30, which is the correct sum of 2 + 4 + 6 + 8 + 10.

This style of programming favors short, clearly named stages. It is highly readable and helps prevent bugs!

Introduction & Quick Recall: Building Data Pipelines

Combining Functions with the . Operator

Join the 1M+ learners on CodeSignal

Cleaning Up Code with the $ Operator

Assembling Complete Pipelines

Course Wrap-Up and Final Practice