passing 2 arguments to a function in Haskell

Question

In Haskell, I know that if I define a function like this add x y = 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?

utdemir · Accepted Answer · 2015-01-31 07:57:27Z

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.)

How does the returned function know about 11? Does it store 11 in its memory & then take 2 as arguments of it.
The returned function is a closure that captures the 11 at the time of its creation, care of lexical scoping.
Note also that one of the most basic optimizations GHC does is not bothering to make an intermediate closure if it's going to be used only for immediate application to a known argument.

Collectives™ on Stack Overflow

passing 2 arguments to a function in Haskell

1 Answer 1

3 Comments

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

3 Comments

Related