# currying

* we can transform a function with multiple arguments into a sequence of nesting functions.
* It returns a new function that expects the next argument inline.
*  It keeps returning a new function *(that expects the current argument, like we said earlier)* until all the arguments are exhausted.
*  The arguments are kept `"alive"`(via closure) and all are used in execution when the final function in the currying chain is returned and executed.

```javascript
function curry(f) { // curry(f) does the currying transform
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}

// usage
function sum(a, b) {
  return a + b;
}

let carriedSum = curry(sum);

carriedSum(1)(2); // 3
```

Example Description:

* The result of `curry(func)` is a wrapper `function(a)`.
* When it is called like `carriedSum(1)`, the argument is saved in the Lexical Environment, and a new wrapper is returned `function(b)`.
* Then `carriedSum(1)(2)` finally calls `function(b)` providing `2`, and it passes the call to the original multi-argument `sum`.

**Advanced currying:**

```javascript
function addCurry(x) {
  return function innrFn(y) {
    if (y !== undefined) {
      x += y;
      return innrFn;
    } else {
      return x;
    }
  }
}

addCurry(1)(2) // [Function: innrFn]
addCurry(1)(2)(); // 3
addCurry(1)(2)(3)(); // 6
```

* when the function call is completed with argument will return the function.
* when function is call is completed without argument will return the sum of all arguments.