柯里化 (Currying)

LincZero大约 8 分钟

柯里化 (Currying)

这篇笔记并不是某个指定语言的 “柯里化”，而是从更广义更宏观的角度上，从设计的角度上来说

计算机科学

参考：https://zh.wikipedia.org/wiki/%E6%9F%AF%E9%87%8C%E5%8C%96

定义

在计算机科学open in new window中，柯里化（英语：Currying），又译为卡瑞化或加里化，是把接受多个参数open in new window的函数open in new window变换成接受一个单一参数（最初函数的第一个参数）的函数，并且返回接受余下的参数而且返回结果的新函数的技术。这个技术由克里斯托弗·斯特雷奇open in new window以逻辑学家哈斯凯尔·加里open in new window命名的，尽管它是Moses Schönfinkelopen in new window和戈特洛布·弗雷格open in new window发明的。

在直觉上，柯里化声称“如果你固定某些参数，你将得到接受余下参数的一个函数”。所以对于有两个变量的函数 $y^x$ ，如果固定了 $y=2$ ，则得到有一个变量的函数 $2^x$ 。

在理论计算机科学open in new window中，柯里化提供了在简单的理论模型中，比如：只接受一个单一参数的lambda演算open in new window中，研究带有多个参数的函数的方式。

函数柯里化的对偶是Uncurrying，一种使用匿名单参数函数来实现多参数函数的方法。例如：

var foo = function(a) {
  return function(b) {
    return a * a + b * b;
  }
}

这样调用上述函数：(foo(3))(4)，或直接foo(3)(4)。

JavaScript

参考：https://zh.javascript.info/currying-partials

介绍

柯里化（Currying）open in new window是一种关于函数的高阶技术。它不仅被用于 JavaScript，还被用于其他编程语言。

柯里化是一种函数的转换，它是指将一个函数从可调用的 f(a, b, c) 转换为可调用的 f(a)(b)(c)。

柯里化不会调用函数。它只是对函数进行转换。

让我们先来看一个例子，以更好地理解我们正在讲的内容，然后再进行一个实际应用。

我们将创建一个辅助函数 curry(f)，该函数将对两个参数的函数 f 执行柯里化。换句话说，对于两个参数的函数 f(a, b) 执行 curry(f) 会将其转换为以 f(a)(b) 形式运行的函数：

// curry(f) 执行柯里化转换
function curry(f) {
  return function(a) {
    return function(b) {
      return f(a, b);
    };
  };
}

// 用法
function sum(a, b) {
  return a + b;
}
let curriedSum = curry(sum);

alert( curriedSum(1)(2) ); // 3

正如你所看到的，实现非常简单：只有两个包装器（wrapper）。

curry(func) 的结果就是一个包装器 function(a)。
当它被像 curriedSum(1) 这样调用时，它的参数会被保存在词法环境中，然后返回一个新的包装器 function(b)。
然后这个包装器被以 2 为参数调用，并且，它将该调用传递给原始的 sum 函数。

lodash 库的 `_.curry`

柯里化更高级的实现，例如 lodash 库的 _.curryopen in new window，会返回一个包装器，该包装器允许函数被正常调用或者以部分应用函数（partial）的方式调用：

function sum(a, b) {
  return a + b;
}

let curriedSum = _.curry(sum); // 使用来自 lodash 库的 _.curry

alert( curriedSum(1, 2) ); // 3，仍可正常调用
alert( curriedSum(1)(2) ); // 3，以部分应用函数的方式调用

柯里化？目的是什么？

要了解它的好处，我们需要一个实际中的例子。

例如，我们有一个用于格式化和输出信息的日志（logging）函数 log(date, importance, message)。在实际项目中，此类函数具有很多有用的功能，例如通过网络发送日志（log），在这儿我们仅使用 alert：

// 原函数
function log(date, importance, message) {
  alert(`[${date.getHours()}:${date.getMinutes()}] [${importance}] ${message}`);
}

// 柯里化函数
log = _.curry(log);

// 正常使用，log(a, b, c)
log(new Date(), "DEBUG", "some debug");
// 柯里化使用，log(a)(b)(c)
log(new Date())("DEBUG")("some debug");
// 分段使用1
let logNow = log(new Date()); // logNow 会是带有固定第一个参数的日志的部分应用函数
logNow("INFO", "message"); // 使用它：[HH:mm] INFO message
// 分段使用2,更进一步
let debugNow = logNow("DEBUG");
debugNow("message"); // [HH:mm] DEBUG message

换句话说，柯里化函数可以进一步变成更简短的“部分应用函数（partially applied function）”或“部分函数（partial）”。

所以：

柯里化之后，我们没有丢失任何东西：log 依然可以被正常调用。
我们可以轻松地生成部分应用函数，例如用于生成今天的日志的部分应用函数。

高级柯里化实现

如果你想了解更多细节，下面是用于多参数函数的“高级”柯里化实现，我们也可以把它用于上面的示例。

它非常短：

function curry(func) {
  return function curried(...args) {
    if (args.length >= func.length) {
      return func.apply(this, args);
    } else {
      return function(...args2) {
        return curried.apply(this, args.concat(args2));
      }
    }
  };
}

用例：

function sum(a, b, c) {
  return a + b + c;
}
let curriedSum = curry(sum);

alert( curriedSum(1, 2, 3) ); // 6，仍然可以被正常调用
alert( curriedSum(1)(2,3) ); // 6，对第一个参数的柯里化
alert( curriedSum(1)(2)(3) ); // 6，全柯里化

新的 curry 可能看上去有点复杂，但是它很容易理解。

curry(func) 调用的结果是如下所示的包装器 curried：

// func 是要转换的函数
function curried(...args) {
  if (args.length >= func.length) { // (1)
    return func.apply(this, args);
  } else {
    return function(...args2) { // (2)
      return curried.apply(this, args.concat(args2));
    }
  }
};

当我们运行它时，这里有两个 if 执行分支：

如果传入的 args 长度与原始函数所定义的（func.length）相同或者更长，那么只需要使用 func.apply 将调用传递给它即可。
否则，获取一个部分应用函数：我们目前还没调用 func。取而代之的是，返回另一个包装器 pass，它将重新应用 curried，将之前传入的参数与新的参数一起传入。

然后，如果我们再次调用它，我们将得到一个新的部分应用函数（如果没有足够的参数），或者最终的结果。

只允许确定参数长度的函数
柯里化要求函数具有固定数量的参数。
使用 rest 参数的函数，例如 f(...args)，不能以这种方式进行柯里化。

比柯里化多一点
根据定义，柯里化应该将 sum(a, b, c) 转换为 sum(a)(b)(c)。
但是，如前所述，JavaScript 中大多数的柯里化实现都是高级版的：它们使得函数可以被多参数变体调用。

总结

柯里化 是一种转换，将 f(a,b,c) 转换为可以被以 f(a)(b)(c) 的形式进行调用。JavaScript 实现通常都保持该函数可以被正常调用，并且如果参数数量不足，则返回部分应用函数。

柯里化让我们能够更容易地获取部分应用函数。就像我们在日志记录示例中看到的那样，普通函数 log(date, importance, message) 在被柯里化之后，当我们调用它的时候传入一个参数（如 log(date)）或两个参数（log(date, importance)）时，它会返回部分应用函数。

与柯里化相关的其他概念

闭包

闭包是实现柯里化的重要途径之一

偏函数

一个评论：

这篇文章我有疑惑, 我网上查阅了一些资料, 偏函数和柯里化应该是两个东西, 或者说柯里化是一个完全版的偏函数(Curried functions are automatically partially applied)
个人理解: :对一个普通函数进行偏函数应用的时候实际上相当于对这个函数预先绑定一些参数默认值, 返回一个绑定了部分参数的函数, 然后再进行传参调用, 比如 const f = partial(fn, _, 100), 这里_代表占位符, 表示这个地方暂时不传参数, 留到下一次调用传, 100为绑定的参数, 然后就可以调用f('test'), 这里的 test就取代了_的位置, 至此完整的参数传递完毕, 函数fn可以被完整的调用了.
换成柯里化过程可能是:const f = curry(fn), 然后你需要一次调用一个参数的f('test')(100).
所以我的想法是, 偏函数的局部应用是将一个 n 个参数的函数转换成一个 n-x 的新函数. 而柯里化直接转为每次值接受一个参数的新函数, 需要 n 次才能调用完毕.
同时, 柯里化只允许参数从左往右依次传递, 偏函数允许使用占位符(placeholder), 传递方向不一定从左到右, 比如我上面的例子. 当然, 这个可能只针对 js 语言. 比如 python 中调用函数是允许使用=约束参数名字的, 比如fn(name='test'), 这样其实也不太存在参数传递的方向性了(我猜的)

方向性的问题不是本质问题，如何获取一个偏函数，这可能是柯里化的一个应用，你定义好参数的顺序，那你可以通过柯里化便捷的产生多个偏函数。我觉得重点还是在柯里化之后每一步对参数的处理和调用上，把每一步的参数调用和处理区分开了，有点类似async/await的思路。

柯里化是偏函数的实现方式之一，偏函数确实更加灵活，并不限定顺序和方向。说实话，我一直觉得翻译“偏函数”这个名词的人有点问题，partial function，实际上就是部分函数的意思，换句话说，是原函数的一部分，其他部分被固定了，不能或者不需要再变动了。