Question: I don't understand composing functions with arity > 1.
in ghci 7.4.1 i typed:

```
((*).succ) 3 4
> 16

```

i don't fully understand the math transformation but it's clear that it's the same as

```
(*) (succ 3) 4

```

but when i do:

```
( (\x y z -> x).(\a b -> a*b) ) 2 3 4 5
> 10
( (\x y z -> y).(\a b -> a*b) ) 2 3 4 5
> No instance for (Num (a0 -> t0))

```

and now i'm totally lost. can anyone explain what happens? ps. I know that everything in haskell has only 1 parameter but it doesn't really help me :)

Answer: 
Combinator `.` is a [function composition](https://en.wikipedia.org/wiki/Function_composition) operator. Let's examine its type:

```
(.) :: (b -> c) -> (a -> b) -> a -> c

```

So it takes the result of the second function and passes it to the first function.

In your example, the important thing to consider is that we can view `*` as a single-argmuent function whose result is a function:

```
(*) :: Num a => a -> (a -> a)

```

It takes a number and returns a function that multiplies its argument by the number. (This approach is called [Currying](https://en.wikipedia.org/wiki/Currying)). The type operator `->` associates to the right, so the parentheses are optional - its just in our minds, if we view `(*)` as a two-argument function returning a number or a one-argument function returning another function.

This helps us view what `(*) . succ` does: It increments its argument (which must be `Enum`), and then converts it into a function that multiplies its argument by the number (so the argument must also be `Num`). The result is then

```
(*) . succ :: (Enum a, Num a) => a -> (a -> a)

```

Again, we can view it as a one-argument function, or more conveniently two-argument function: It increments its first argument and multiplies it with the second.
In 

```
( (\x y z -> x).(\a b -> a*b) ) 2 3 4 5

```

1. they first evaluate (\a b -> a\*b) 2 resulting in function like this (\b -> 2\*b)
2. then evaluate (\x y z -> x) (\b -> 2\*b) 3 4 that say that take the function take the 3 and take the 4 and return the function, something like this: ((\b -> 2\*b) 3 4 -> (\b -> 2\*b))
3. and only remains (\b -> 2\*b) 5 resulting 2\*5 = 10

but in

```
( (\x y z -> y).(\a b -> a*b) ) 2 3 4 5

```

the second evaluation will result in this ((\b -> 2\*b) 3 4 -> 3) remaining 3 5 causing a error