Question: I'm having trouble understanding curried and uncurried functions. All the sites I Google'd to try to provide me a definition were unclear to me.

In one example I found them saying that

`max 4 5` is the same as `(max 4) 5`

But I don't understand what they're doing. How can you have a function `(max 4)` when max requires 2 parameters? I'm completely lost.

Answer: 
Depending on your background, you may find this paper enlightening: **[How to Make a Fast Curry: Push/Enter vs Eval Apply](http://research.microsoft.com/en-us/um/people/simonpj/Papers/eval-apply/index.htm)**. While it's true that multi-argument functions can be understood as functions which bind a single parameter and return another function: `max = (\a -> (\b -> if a > b then a else b))`, the actual implementation is quite a bit more efficient.

If the compiler knows statically that `max` requires two arguments, the compiler will always translate `max 4 5` by pushing the two arguments on the stack (or in registers) and then invoking `max`. This is essentially the same as how a C compiler would translate `max(4, 5)`.

On the other hand, if for instance `max` is an argument to a higher-order function, the compiler may not know statically how many arguments `max` takes. Perhaps in one instance it takes three, so `max 4 5` is a partial application, or perhaps in another it takes only one and `max 4` generates a new function to which `5` is applied. The paper discusses the two common approaches to handling the case where the arity isn't known statically.
To relate to your own example...

Suppose that you want a function that gives the maximum of 4 and the functions argument. You could implement it like this:

```
max4 :: Integer -> Integer
max4 x = max 4 x

```

What `max 4` does is just to return the function `max4` created on the fly.