haskell - Uncurried functions -

I'm having trouble understanding the curried and uncurried tasks.

In one example I found them saying that

maximum 4 5 (max 4) 5

is similar, but I do not know what they are doing. When you can require a maximum of 2 parameters, how can you do a function (max 4) I'm completely lost.

The move with Haskell is that the task only takes one argument. It seems completely crazy but it really works.

A hascal function:

  foo :: int -> Int - & gt; In fact it means: A logic that takes 1 argument, and then  gives another task which takes an argument  It is called curry.  
 Therefore, we can actually write this function definition as follows:  
  foo :: int -> (Int -> int) - speak in mathematics: correct associative   
 And actually the same thing means.  
 This is really super useful because now we can write short codes like:  
  foo1 :: int -> IT foo1 = foo 1   
 Since the headcount in the action is Haskell is just whitespace, most of the time when you show that the curved functions are uncurried (take more than one argument and just return one result is) .  
 If you really need any unpleasant work: use tuples.  
  uncFoo :: (Int, Int) - & gt; To understand what is happening with a partial applicant,     
  edit   
 Int Anfu (a , B) = a + b <> bar   
  bar abc = [a, b, c]   
 this is the compiler What you will be typing right now Such lambda  
  bar = \ a - & gt; \ B - & gt; \ C - & gt; [A, B, C]   
 It takes advantage of closing (each internal function can remember 'logic' to the previous ones.)  
 So when We say  Bar 1  goes to the compiler and looks at  bar  and looks at the outermost lambda, and  
  bar 1 = If we say that  bar 1 2   
  times 1 2 If I say "applicable" is blurred, then it means that I mean really from Lambda calculus.