JavaScript. Подробное руководство, 6-е издание

   а = a.concat(array(args,1)); // Добавить внешние арг., начиная с 1.
   return f.apply(this, а); // Вызвать f с этим списком аргументов
   };
  }

  // Аргументы этой функции играют роль шаблона. Неопределенные значения
  // в списке аргументов заполняются значениями из внутреннего набора,
  function partial(f /*, ... */) {
var args = arguments; // Сохранить внешний массив аргументов
   return function {
   var a = array(args, 1); // Начинать с внешнего массива аргументов
   var i=0, j=0;
   // Цикл по этим аргументам, заменить значения undefined значениями
   // из внутреннего списка аргументов
   for(; і < a.length; i++)
   if (a[i] === undefined) a[i] = arguments[j++];
   // Добавить оставшиеся внутренние аргументы в конец списка
   а = a.concat(array(arguments, j))
   return f.apply(this, a);
   };
  }

  // Ниже приводится функция, принимающая три аргумента
  var f = function(x,y,z) { return x * (у - z); };
  // Обратите внимание на отличия между следующими тремя частичными применениями
  partialLeft(f, 2)(3,4) // => -2: Свяжет первый аргумент: 2 * (3 - 4)
  partialRight(f, 2)(3,4) // => 6: Свяжет последний аргумент: 3 * (4 - 2)
  partial(f, undefined, 2)(3,4) // => -6: Свяжет средний аргумент: 3 * (2 - 4)

Эти функции частичного применения позволяют легко объявлять новые функции на основе уже имеющихся функций. Например:

  var increment = partialLeft(sum, 1);
  var cuberoot = partialRight(Math.pow, 1/3);
  String.prototype.first = partial(String.prototype.charAt, 0);
  String.prototype.last = partial(String.prototype.substr, -1, 1);

Прием частичного применения становится еще более интересным, когда он используется в комбинации с функциями высшего порядка. Например, ниже демонстрируется еще один способ определения функции not, представленной выше, за счет совместного использования приемов композиции и частичного применения:

  var not = partialLeft(compose, function(x) { return !x; });
  var even = function(x) { return x % 2 === 0; };
  var odd = not(even);
  var isNumber = not(isNaN)

Прием композиции и частичного применения можно также использовать для вычисления среднего значения и стандартного отклонения в крайне функциональном стиле:

  var data = [1,1.З,5,5]; // Исходные данные
  var sum = function(x.y) { return x+y; }; // Две элементарные функции
  var product = function(x,у) { return x*y; };

  var neg = partial(product, -1); // Определения других функций
  var square = partial(Math.pow, undefined, 2);
  var sqrt = partial(Math.pow, undefined, .5);
  var reciprocal = partial(Math.pow, undefined, -1);
  // Вычислить среднее и стандартное отклонение. Далее используются только функции
  // без каких либо операторов, отчего программный код начинает напоминать
  // программный код на языке Lisp!
  var mean = product(reduce(data, sum), reciprocal(data.length));
  var stddev = sqrt(product(reduce(map(data, compose(square,
   partial(sum, neg(mean)))), sum),
   reciprocal(sum(data.length,-1))));

8.8.4. Мемоизация

В разделе 8.4.1 была определена функция нахождения факториала, которая сохраняет ранее вычисленные результаты. В функциональном программировании такого рода кэширование называется мемоизацией (memorization). В следующем примере демонстрируется функция memoize высшего порядка, которая принимает функцию в виде аргумента и возвращает ее мемоизованную версию:

  // Возвращает мемоизованную версию функции f. Работает, только если все возможные
  // аргументы f имеют отличающиеся строковые представления,
  function memoize(f) {
   var cache = {}; // Кэш значений сохраняется в замыкании,
   return function {
   // Создать строковую версию массива arguments для использования
   // в качестве ключа кэша.
   var key = arguments.length + Array.prototype.join.call(arguments,",")