# Add(1)(2)… (infinity)

You probably already know that JavaScript is an incredibly flexible language. I would like to share one of my favourite examples of what it really enables you to do.

Lets begin with creating a function `add`

that accepts two arguments, `a`

and` b`

and returns the sum:

`const add = (a, b) => a + b;`

Pretty straight forward; however, what if you would like to add the second number later? Say you would want to do the following:

`var addFour = add(4);`

...

addFour(2) // returns 6

It can actually be done with the help of a technique called *currying, *which turns out to be one of the cornerstones in functional programming. Don’t be scared, it is simpler than you think:

const add = (a) => (b) => a + b;

It basically returns a new function that `addFour`

in the example above will reference to. I’ll make it crystal clear:

`var addFour = add(4); // returns a function`

`addFour = (b) => 4 + b; // reference to function`

Cool, huh?

However, wouldn’t it be more convenient to be able to do this indefinitely?

Impossible right? No, not in JS. It turns out we can alter the value of the function itself, to return a primitive value that is our sum. Combined with the ability to return functions we can easily write something along these lines:

const add = (sum) => {

const fn = (b) => add(sum + b);

fn.valueOf = () => sum;

return fn;

}

Now we can actually call the function like this:

add(2)(3)(4)(2) // returns 11

add(1)(2) // returns 3

add(3)(1)(4) + 3 // returns 11

I hope you enjoyed the reading! :)