Dot Operator in Haskell: need more explanation

Question

I\'m trying to understand what the dot operator is doing in this Haskell code:

sumEuler = sum . (map euler) . mkList

The entire source code

Answer 1

Dot Operator in Haskell

I'm trying to understand what the dot operator is doing in this Haskell code:

sumEuler = sum . (map euler) . mkList

Short answer

Equivalent code without dots, that is just

sumEuler = \x -> sum ((map euler) (mkList x))

or without the lambda

sumEuler x = sum ((map euler) (mkList x))

because the dot (.) indicates function composition.

Longer answer

First, let's simplify the partial application of euler to map:

map_euler = map euler
sumEuler = sum . map_euler . mkList

Now we just have the dots. What is indicated by these dots?

From the source:

(.)    :: (b -> c) -> (a -> b) -> a -> c
(.) f g = \x -> f (g x)

Thus (.) is the compose operator.

Compose

In math, we might write the composition of functions, f(x) and g(x), that is, f(g(x)), as

(f ∘ g)(x)

which can be read "f composed with g".

So in Haskell, f ∘ g, or f composed with g, can be written:

f . g

Composition is associative, which means that f(g(h(x))), written with the composition operator, can leave out the parentheses without any ambiguity.

That is, since (f ∘ g) ∘ h is equivalent to f ∘ (g ∘ h), we can simply write f ∘ g ∘ h.

Circling back

Circling back to our earlier simplification, this:

sumEuler = sum . map_euler . mkList

just means that sumEuler is an unapplied composition of those functions:

sumEuler = \x -> sum (map_euler (mkList x))