Gitter/javascript

@SeifESlimene Not every function that returns another function is a curried function, though. Suppose you call a "normal" (i.e., non-curried) function that takes three arguments.

foo(a, b, c)

If foo was curried, you'd be calling it like this intead:

foo(a)(b)(c)

So basically, every curried function takes only one argument at a time. As long as you haven't provided all the arguments that are required, you just get another function that takes one argument. So foo is a function that takes one argument, foo(a) is a function that takes one argument, foo(a)(b) is a function that takes one argument, and finally foo(a)(b)(c) is the same value that the uncurried foo(a, b, c) would return.

Now, the use case mostly comes in with partial application. Suppose I already know which a and b I want to pass to foo, but I want to leave the choice of a c to some other function bar. Naievely, in the uncurried case, I might just pass a and b as additional arguments to bar and have it make the final call to foo:

-- definition of bar
function bar(a, b)
    return foo(a, b, c)
end bar

-- later, calling bar
bar(a, b)

However, that requires that bar already knows that I want to call foo. What if bar is a more generic function, which just expects any single-argument function and then passes c to it? How do I ensure that it will invoke foo with a and b already passed? In the uncurried case, I can write a wrapper function for this purpose:

-- definition of bar
function bar(func)
    return func(c)
end bar

-- wrapping foo
function wrapFoo(a, b)
    return function(c)
        foo(a, b, c)
    end
end wrapFoo

-- finally, calling bar
bar(wrapFoo(a, b))

Libraries for uncurried programming languages often provide a helper function so you don't have to write wrapFoo yourself. For example _.partial in Underscore for JavaScript. With such a helper function, we can do the same as above in less code:

-- definition of bar
function bar(func)
    return func(c)
end bar

-- calling bar
bar(partial(foo, a, b))

In curried programming languages, however, you don't even need a helper function like partial:

-- definition of bar
function bar(func)
    return func(c)
end bar

-- calling bar
bar(foo(a)(b))

I hope the added value of currying is clearer this way. Let me know if you still have questions.

As a final remark, while some programming languages are curried by default and others are not, you can have both flavors in either type of programming language. In uncurried languages, you can write a curry helper function that turns any function taking multiple arguments into a function that takes one argument at a time. In curried languages, you can write a function that accepts a tuple of values in order to simulate an uncurried function.