Javascript currying function

This isn't a great example for teaching currying. I think what the instructor/course is trying to get across here is that when you do:

let result = calculate(add, subtract, multiply)(1,3)

you're calling a function (calculate) that returns a function (one of the three you pass it, I guess picked at random though the assignment is unclear), and then you're calling that function (by using (1,3) on the result of the calculate(...) call.

calculate can be a one-liner:

function calculate(...fns) {
    return fns[Math.floor(Math.random() * fns.length)];
}

or in ES5:

function calculate() {
    return arguments[Math.floor(Math.random() * arguments.length)];
}

Live Example:

function add(num1, num2){
  return num1 + num2;
}

function subtract(num1, num2){
  return num1 - num2;
}

function multiply(num1, num2){
  return num1 * num2;
}

function calculate(...fns) {
    return fns[Math.floor(Math.random() * fns.length)];
}

let result = calculate(add, subtract, multiply)(1,3);
console.log(result);

A more useful example to teach currying would be:

let result = calculate(add, subtract, multiply)(1)(3);
// ----------------------------------------------^^

Notice that we're calling the result of calculate with 1, then calling the result of that with 3. Then, calculate would need to wrap the function it picks in another function that collects the 1 and then waits to be called with the 3:

function calculate(...fns) {
    const fn = fns[Math.floor(Math.random() * fns.length)];
    return (a) => {
        return (b) => {
            return fn(a, b);
        };
    };
}

or more concisely, but less clearly:

function calculate(...fns) {
    const fn = fns[Math.floor(Math.random() * fns.length)];
    return (a) => (b) => fn(a, b);
}

Live Example:

function add(num1, num2){
  return num1 + num2;
}

function subtract(num1, num2){
  return num1 - num2;
}

function multiply(num1, num2){
  return num1 * num2;
}

function calculate(...fns) {
    const fn = fns[Math.floor(Math.random() * fns.length)];
    return (a) => (b) => fn(a, b);
}

let result = calculate(add, subtract, multiply)(1)(3);
console.log(result);

The function returned by calculate, when called, remembers a and returns a new function; that function, when called, gets b and calls fn(a, b) to get the result.

That example picks the function up-front, but it could pick it at the end as well:

function calculate(...fns) {
    return (a) => (b) => fns[Math.floor(Math.random() * fns.length)](a, b);
}

Live Example:

function add(num1, num2){
  return num1 + num2;
}

function subtract(num1, num2){
  return num1 - num2;
}

function multiply(num1, num2){
  return num1 * num2;
}

function calculate(...fns) {
    return (a) => (b) => fns[Math.floor(Math.random() * fns.length)](a, b);
}

let result = calculate(add, subtract, multiply)(1)(3);
console.log(result);

You could take a random function from the arguments and return this function for another call with parameters.

const
    add = (a, b) => a + b,
    subtract = (a, b) => a - b,
    multiply = (a, b) => a * b,
    calculate = (...args) => args[Math.floor(Math.random() * args.length)];

let result = calculate(add, subtract, multiply)(1, 3);

console.log(result);

calculate should return one of the functions so the result of the calculate function should be called with the actual params:

function add(num1, num2){
  return num1 + num2;
}

function subtract(num1, num2){
  return num1 - num2;
}

function multiply(num1, num2){
  return num1 * num2;
}

function calculate(add, subtract, multiply){

  let randNum = Math.floor(Math.random() * 3) + 1

  switch(randNum){
    case 1:
      return add
      break;

    case 2:
      return subtract
      break;

    case 3:
      return multiply
      break;

  }

}

console.log(calculate(add, subtract, multiply)(2, 4));

You have two problems in this part of the code, inside your calculate function:

  switch(randNum){
    case 1:
      let add = add(num1, num2)
      break;

    case 2:
      let subtract = subtract(num1, num2);
      break;

    case 3:
      let multiply = multiply(num1, num2);
      break;

1. You're calling you math functions (ej. add(num1, num2)) inside calculate. This will return a number but the expected behaviour is that it will return a function, so that you can call it with further parameters:

   let result = calculate(add, subtract, multiply)(1,3)
   

   
   

2. Your calculate function is not returning any value. Thus, when your doing let result = calculate(...), result will always be undefined.

Instead of this, your calculate function should return a function:

    function calculate(add, subtract, multiply){

      let randNum = Math.floor(Math.random() * 3) + 1;

      switch(randNum){
          case 1:
          return add;

          case 2:
          return subtract;

          case 3:
          return multiply;
      }
    }

Demo: https://jsbin.com/jiholifife/edit?js,console

Note the difference: your function calculate is now returning a function.
This is possible due to the fact that functions in JavaScript are First-Class objects: a function can be passed as an argument to other functions, can be returned by another function and can be assigned as a value to a variable.