mul(2)(3)(4) === 24 is a currying + closure problem with a twist: the result of each call is a function (so it can be called again), but it must also be usable as the number.

The naive version (fixed arity)

If it's always exactly three calls:

const mul = (a) => (b) => (c) => a * b * c;
mul(2)(3)(4); // 24

Clean, but mul(2)(3) would be a function, not 6 — and it only handles 3 args.

The real ask: infinite chaining — mul(2)(3)(4)...

Each call returns a function carrying the running product. The key trick: that function needs to coerce to its numeric value when compared or used as a number, via valueOf (or toString):

function mul(a) {
  function next(b) {
    return mul(a * b);          // return another chainable function
  }
  next.valueOf = () => a;       // coercion: makes it usable as the number
  next.toString = () => String(a);
  return next;
}

mul(2)(3)(4) == 24;   // true  — == triggers valueOf
+mul(2)(3)(4);        // 24    — unary + triggers valueOf

• Every mul(x) returns next, which is callable (chain continues) and has a valueOf so JS coerces it to the accumulated product in numeric contexts.
• Note: === won't coerce — mul(2)(3)(4) === 24 is false because it's strictly a function. Use ==, +x, or template/string context. Interviewers usually accept == / explain this nuance.

What this tests

• Closures — the running product captured across calls.
• Currying / function returning function.
• Type coercion — valueOf/toString and when JS invokes them. Knowing === won't coerce is the senior detail.

Variation: sum that works with any number of calls

Same pattern: add(1)(2)(3) with valueOf accumulating. The technique generalizes to any "chainable accumulator."