Can you be more specific?

Yeah, currying is weird. There are different ways to think about it, but here you can think of it that instead of having 1 function that takes 2 parameters, they make two functions that each take one parameter - the first function takes 1 parameter each and the first function returns the second function.

```
const unCurried = (x, y) => x + y;
console.log(unCurried(1, 2));
// 3
// ***
const curried = x =>
y => x + y;
console.log(curried(1)(2));
// 3
// ***
function curried2(x) {
return function(y) {
return x + y;
}
}
console.log(curried2(1)(2));
// 3
// ***
const returnedFunction = curried(1);
const answer = returnedFunction(2);
console.log(answer);
// 3
```

The first example is of course a “normal” function, one function taking one parameter.

The second example is of course a curried function. Notice that there are two functions - the first returning the second. The second returned function is `y => x + y;`

and it is returned by the first half, `x =>`

. So, `f(x, y)`

becomes `f(x)(y)`

. `f(x)`

returns a function that gets executed by the `(y)`

.

The third example is the same as the second but written out with standard JS functions.

The last shows that you can run those functions separately. I can run the first one that returns a function and I can execute it later. It may not be clear now, but that does come in handy.