Есть ли способ добиться каррирования с локальной переменной?

Вы можете сделать это следующим образом:

Функция innerSum поддерживает замыкание по res. Это позволяет res сохранять свое значение при нескольких вызовах innerSum.

function sum(a) {
  let res = a;
  function innerSum(b) {
    if (b !== undefined) {
      res += b;
      return innerSum;
    } else {
      return res;
    }
  }
  innerSum.toString = function() {
    return res;
  };
  return innerSum;
}

Демо

function sum(a) {
  let res = a;
  function innerSum(b) {
    if (b !== undefined) {
      res += b;
      return innerSum;
    } else {
      return res;
    }
  }
  innerSum.toString = function() {
    return res;
  };
  return innerSum;
}

console.info(sum(1)(2)(3)(4)(5)(6)().toString());

Вы можете сделать sum IIFE и поместить res в локальную область видимости. После этого при вызове без аргументов сбросьте res на 0, чтобы подготовить его к следующему вызову.

const sum = (() => {
  let res = 0;
  
  return function (a) {
    if (typeof a === 'number') {
      res = res + a;
      return sum;
    } else {
      const temp = res;
      res = 0;
      return temp;
    }
  }
})();

console.info(sum(1)(2)(3)());
console.info(sum(1)(2)(3)(4)());

Его также можно сократить, используя более простой, но, возможно, проклятый синтаксис:

const sum = (res => a => {
  if (typeof a === 'number') {
    res = res + a;
    return sum;
  }
  
  try {
    return res;
  } finally {
    res = 0;
  }
})(0);

console.info(sum(1)(2)(3)());
console.info(sum(1)(2)(3)(4)());

(Обновлено, чтобы включить в комментарии предложение Мулан.)

Интересная альтернатива — воспользоваться valueOf, toString и toJSON, чтобы нам не приходилось выполнять последний пустой вызов:

const sum = (a) => Object.assign(
  (b) => sum(a + b), 
  {valueOf: () => a, toString: () => `${a}`, toJSON: () => a }
)

Например, sum(1)(2)(3) — это функция, но поскольку у нее есть метод valueOf, мы можем использовать ее для дальнейших вычислений, как если бы это было число:

sum(1)(2)(3) * 10                            //=> 60

И если мы используем его при построении строк, будет использоваться версия его значения toString:

console.info(sum(1)(2)(3))                   //=> 6
`The total is ${sum(1)(2)(3)}`              //=> "The total is 6"

Обратите внимание, что sum(1)(2)(3) — это неизменяемая оболочка значения 6. Добавление новых вызовов просто вернет новые функции, которые не мешают друг другу:

const firstThree = sum(1)(2)(3)

console.info(firstThree(4)(5)(6))             //=> "21"
console.info(firstThree(10))                  //=> "16" (previous 4, 5, 6 ignored)

Это полезно, но не панацея. Есть места, где функциональная природа нашего значения может вызвать проблемы. Первое, что приходит на ум, — использовать ли это как значение JSON:

console.info(JSON.stringify({a: 4, b: sum(1)(2)(3), c: 10}))//=> {a, 4, c: 10}                           // *** Note that `b` is missing ***

Поэтому вам нужно будет определить, есть ли у вас подобные варианты использования. Если нет, то это довольно элегантная версия, как в использовании, так и в реализации.

Обновите предложение Мулан об использовании toJSON, а также valueOf и toString, что означает, что мы можем извлечь представление JSON, которое включает текущее значение этой функции. Конечно, он больше не имеет динамического поведения, но этого и следовало ожидать, когда он был сериализован в строку.

console.info(JSON.stringify({a: 4, b: sum(1)(2)(3), c: 10}))
//=> '{"a", 4, "b": 6, "c": 10}'             // *** Note that `b` is now fixed ***  

Вы можете протестировать все это в своем браузере в следующем фрагменте:

const sum = (a) => Object.assign(
  (b) => sum(a + b), 
  {valueOf: () => a, toString: () => `${a}`, toJSON: () => a }
)

const res = sum(1)(2)(3) * 10               
console.info(res)                             //=> 60

console.info(sum(1)(2)(3))                    //=> 6
console.info(`The total is ${sum(1)(2)(3)}`)  //=> "The total is 6"

const firstThree = sum(1)(2)(3)

console.info(firstThree(4)(5)(6))             //=> "21"
console.info(firstThree(10))                  //=> "16" (previous 4, 5, 6 ignored)

console.info(JSON.stringify({a: 4, b: sum(1)(2)(3), c: 10}))
//=> '{"a", 4, "b": 6, "c": 10}'             // *** Note that `b` is now fixed ***

.as-console-wrapper {max-height: 100% !important; top: 0}

Вы можете определить sum так:

const sum = a => b =>
  b == null ? a : sum(a + b)
  
console.info(sum(1)(2)(3)(4)()) // 10

console.info(sum(11)(11)(11)()) // 33

Если вы хотите поддержать sum() и вернуть 0, необходимо еще одно условие -

const sum = a =>
  a == null
    ? 0
    : b =>
        b == null ? a : sum(a + b)

console.info(sum(1)(2)(3)(4)()) // 10

console.info(sum(11)(11)(11)()) // 33

console.info(sum()) // 0

sum немного негибкий и поддерживает только сложение. Лучший шаблон, разрешающий любую функцию, можно увидеть, продемонстрировав go ниже:

function go(a) {
  return function map(fn) {
    return go(fn(a))
  }
}

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

const mul = (a) => (b) => a * b

go(2)           // 2
  (add(3))      // 5
  (add(4))      // 9
  (mul(11))     // 99
  (console.info) // => 99

Далее мы увидим go как хорошо типизированную функцию —

interface Go<A> {
  <B>(fn: (a: A) => B): Go<B>
}

function go<A>(a: A) {
  return function map<B>(fn: (a: A) => B): Go<B> {
    return go(fn(a))
  }
}

const add = (a: number) => (b: number) =>
  a + b

const mul = (a: number) => (b: number) =>
  a * b

Попробуйте на игровой площадке для машинописи

Если безопасность типов вас не беспокоит, вы можете написать go просто:

const go = x => fn => go(fn(x))