How does "multi-argument" functional composition work (e.g. fmap . fmap)?

Question

When we have the expression:

(fmap . fmap) function nested_functor

I would expect it to translate to something like

fmap (fmap function nested_functor)

Though it surprisingly seems to behave as

fmap (fmap function) nested_functor

Why?

• n. m. could be an AI: All functions are single-argument, i.e. a->b->c is the same as a->(b->c). Build from here.
• Will Ness: ... and so f x y is the same as (f x) y. (f :: a->(b->c), x :: a, y :: b)

Answer 1

Well, just look at the definition of (.):

(f . g) x = f (g x)

So,

(fmap . fmap) function = fmap (fmap function)

Adding an additional argument at the end doesn't really change the equation -- just makes it more specific.

(fmap . fmap) function nested_functor = fmap (fmap function) nested_functor

(N.B. function application is left associative, so f x y means (f x) y.)

• Pedro Rolo: Thank you! My confusion was due to thinking through this as if function application would be right associative, and the mess was due to that (->) associating to the right in the type signatures... I am now finding it funny that functional application in type declarations has a different associativity than in the expressions themselves.
• David Young: @PedroMorteRolo It is sort of symmetrical that way. With it set like it is, you can have no parentheses in an application of fn to 'two' arguments as fn x y and no parentheses in the corresponding type signature for fn :: Int -> Int -> Bool (for example). If they associated in the same way (regardless of which way that is), one of those two things would need parens and the other wouldn't.