将2个参数传递给Haskell中的函数

Question

In Haskell, I know that if I define a function like this add xy = x + y
then I call like this add e1 e2 . that call is equivalent to (add e1) e2
which means that applying add to one argument e1 yields a new function which is then applied to the second argument e2 .

That's what I don't understand in Haskell. in other languages (like Dart), to do the task above, I would do this

add(x) {
  return (y) => x + y;
}

I have to explicitly return a function. So does the part "yields a new function which is then applied to the second argument" automatically do underlying in Haskell? If so, what does that "hiding" function look like? Or I just missunderstand Haskell?

Answer 1

In Haskell, everything is a value,

add x y = x + y

is just a syntactic sugar of:

add = \x -> \y -> x + y

For more information: https://wiki.haskell.org/Currying :

In Haskell, all functions are considered curried: That is, all functions > in Haskell take just single arguments.

This is mostly hidden in notation, and so may not be apparent to a new Haskeller. Let's take the function

div :: Int -> Int -> Int

which performs integer division. The expression div 11 2 unsurprisingly evaluates to 5. But there's more that's going on than immediately meets the untrained eye. It's a two-part process. First,

div 11

is evaluated and returns a function of type

Int -> Int

Then that resulting function is applied to the value 2, and yields 5. You'll notice that the notation for types reflects this: you can read

Int -> Int -> Int

incorrectly as "takes two Ints and returns an Int", but what it's really saying is "takes an Int and returns something of the type Int -> Int" -- that is, it returns a function that takes an Int and returns an Int. (One can write the type as Int x Int -> Int if you really mean the former -- but since all functions in Haskell are curried, that's not legal Haskell. Alternatively, using tuples, you can write (Int, Int) -> Int, but keep in mind that the tuple constructor (,) itself can be curried.)