Function composition is a way of combining two functions to produce a new function. If we have a function $f :: b \to c$ and a function $g :: a \to b$, we can combine $f$ and $g$ to produce a new function $f \circ g :: a \to c$. In Haskell this is defined as `f . g = \x -> f (g x)`

. So "`f`

compose `g`

" means call `g`

with an argument, and pass the result as the argument to `f`

. We can use this to assemble chains of multiple functions such as `a . b . c . …`

.

Composed functions are read right-to-left; `f = a . b . c`

is equivalent to `f x = a (b (c x))`

. So if we have a composed function `(++ "!") . (++ " world") . reverse`

and call it with "olleh", it will first be reversed to give "hello", then have "world" appended, then "!" to give us "hello world!".

I recently had a case where I wanted to compose functions, but I was thinking about the problem in a slightly different way. Rather than composing right-to-left, I wanted to perform a series of operations, and chain the output from the first function into the input of the second function, and so on.

In other words, I wanted left-to-right composition, rather than right-to-left. To do this we can define a new operator to reverse the order in which functions are composed.

It turns out that Haskell already has this operator defined in Control.Arrow, so all I really needed was `import Control.Arrow`

.

As an aside, I also realised that Haskell lets us use line-breaks and indents if we want to write either form of composition in a more imperative style, similar to do-notation: