[tomp]

No, you're wrong. `A(B(C(D)))` is different from `(((A B) C) D)` (which is the parenthesized version of `A B C D`).

Currying allows simple partial application; if A is a function that "takes 3 arguments" (i.e. it has type `w -> x -> y -> z`, which means that it takes an argument of type `w` and returns a function with type `x -> y -> z`, which takes an argument ...), you can say e.g.

  A_ = A B C
  E1 = A_ D1
  E2 = A_ D2

where `A_` is the partially applied function `A`.

[michaelcampbell]

> No, you're wrong.

And you and he both gave evidence to the initial assertion that "it's confusing".

[gamegoblin]

I'm not sure if "confusing" is fair -- just different than C-family languages.

The rule is simply "The first expression is a function, all following expressions are arguments to that function"

It's no different than "The first symbol is a function, all comma-separated, parentheses-bound expressions are arguments to that function"

Both are pretty easy syntactic rules, I think.

[JoeAltmaier]

Its arguably confusing, due to the lack of parentheses factoring a list of functions into one or more invocations. How is the nesting done here? Something more subtle. A lifetime of reading parenthesized functions is going to be confounded by changing the convention - which equals 'confusing'

[gamegoblin]

I think you're probably overestimating the difference. Here is an algorithm for mechanically transforming a C function call to a Haskell function call:

    for all arguments in the function
        if the argument is not a symbol surround it with parentheses
    delete all commas
    delete the two initial parentheses 

And an algorithm for converting Haskell calls to C calls:

    put an open parenthesis between the first expression and second expression
    put a close parenthesis at the end of the expression
    put commas between all expressions between these two parentheses

The fact that it's so easy to convert between them highlights to me that they are both pretty easy.

[tormeh]

I understand currying and partial function application. That's not the problem. The problem is that function application whitespace demands an arbitrary application precedence and obscures function signature to the reader.

[tomp]

ah, that. Well, you get used to it. Also, it helps that application has the highest precedence, so it's quite easy to read expressions like `f x y + g z` (i.e. `(f x y) + (g z)`).