# Order of parameters and currying

I got really confused when reading A Gentle Introduction To Haskell, version 98 (page 10, Functions), which aim to explain currying as the first concept of describing functions.

- Type definitions with
`->`

operator is right associative. - Function calls with parameters separated by space (" ") are left associative.
- Parameters are ordered from left to right both in type definitions and function calls.

For example see the type definition of `div`

.

```
> :t div
:: (Integral a) => a -> a -> a
```

- Numbering the parameters,
`a1 -> a2 -> a3`

- Using right associative rule for
`->`

operator,`a1 -> (a2 -> a3)`

So the type definition roughly translates to:

- A value of
`a1`

applied to function div evaluates a function - A value of type
`a2`

applied to this function evaluates to a value of type`a3`

Calling `div`

with parameters `10`

and `2`

give the result `5`

.

```
> div 10 2
=> 5
```

- Using left associative rule for parameters in function calls,
`(div 10) 2`

This means that the function returned by applying `10`

to `div`

translates to `10/x`

. `2`

applied to this function evaluates to 5.

10 is of type a1, 2 of type a2 and 5 of type a3.

The infix operator of div works in the same manner.

```
> :t (/)
:: (Fractional a) => a -> a -> a
> (/) 10 2
=> 5.0
> 10 / 2
=> 5.0
> 10 `div` 2
=> 5
```

So the div can be defined as.

```
div a b = a / b
```

Note also that operators can have different priority and "associativeness". This is defined by `infix`

, `infixl`

and `infixr`

functions. But functions and `->`

in type definitions work as explained above.

The "function application" operator, `$`

, can be used to change the left associative rule for function argument application.

```
f $ x = f x
```

One example where you want to apply several functions at the same time and want to avoid parentheses.

```
Prelude> let inc = (+) 1
Prelude> inc div 10 2
The function `inc' is applied to three arguments,
Prelude> inc $ div 10 2
6
Prelude> inc (div 10 2)
```

So you can make multiple function applications right associative.

## References

Also see Lambda Calculus: Motivation for an mathematical example of currying.