debug

组合的一个常见错误是，在没有局部调用之前，就组合类似 map 这样接受两个参数的函数。

  1. // 错误做法：我们传给了 `angry` 一个数组，根本不知道最后传给 `map` 的是什么东西。
  2. var latin = compose(map, angry, reverse);
  4. latin(["frog", "eyes"]);
  5. // error
  8. // 正确做法：每个函数都接受一个实际参数。
  9. var latin = compose(map(angry), reverse);
  11. latin(["frog", "eyes"]);
  12. // ["EYES!", "FROG!"])

如果在 debug 组合的时候遇到了困难，那么可以使用下面这个实用的，但是不纯的 trace 函数来追踪代码的执行情况。

  1. var trace = curry(function(tag, x){
  2.   console.log(tag, x);
  3.   return x;
  4. });
  6. var dasherize = compose(join('-'), toLower, split(' '), replace(/\s{2,}/ig, ' '));
  8. dasherize('The world is a vampire');
  9. // TypeError: Cannot read property 'apply' of undefined

这里报错了，来 trace 下：

  1. var dasherize = compose(join('-'), toLower, trace("after split"), split(' '), replace(/\s{2,}/ig, ' '));
  2. // after split [ 'The', 'world', 'is', 'a', 'vampire' ]

啊！toLower 的参数是一个数组，所以需要先用 map 调用一下它。

  1. var dasherize = compose(join('-'), map(toLower), split(' '), replace(/\s{2,}/ig, ' '));
  3. dasherize('The world is a vampire');
  5. // 'the-world-is-a-vampire'

trace 函数允许我们在某个特定的点观察数据以便 debug。像 haskell 和 purescript 之类的语言出于开发的方便，也都提供了类似的函数。

组合将成为我们构造程序的工具，而且幸运的是，它背后是有一个强大的理论做支撑的。让我们来研究研究这个理论。

范畴学

范畴学（category theory）是数学中的一个抽象分支，能够形式化诸如集合论（set theory）、类型论（type theory）、群论（group theory）以及逻辑学（logic）等数学分支中的一些概念。范畴学主要处理对象（object）、态射（morphism）和变化式（transformation），而这些概念跟编程的联系非常紧密。下图是一些相同的概念分别在不同理论下的形式：

debug - 图1

抱歉，我没有任何要吓唬你的意思。我并不假设你对这些概念都了如指掌，我只是想让你明白这里面有多少重复的内容，让你知道为何范畴学要统一这些概念。

在范畴学中，有一个概念叫做…范畴。有着以下这些组件（component）的搜集（collection）就构成了一个范畴：

  • 对象的搜集
  • 态射的搜集
  • 态射的组合
  • identity 这个独特的态射

范畴学抽象到足以模拟任何事物，不过目前我们最关心的还是类型和函数，所以让我们把范畴学运用到它们身上看看。

对象的搜集

对象就是数据类型，例如 String、Boolean、Number 和 Object 等等。通常我们把数据类型视作所有可能的值的一个集合（set）。像 Boolean 就可以看作是 [true, false] 的集合，Number 可以是所有实数的一个集合。把类型当作集合对待是有好处的，因为我们可以利用集合论（set theory）处理类型。

态射的搜集

态射是标准的、普通的纯函数。

态射的组合

你可能猜到了，这就是本章介绍的新玩意儿——组合。我们已经讨论过 compose 函数是符合结合律的，这并非巧合，结合律是在范畴学中对任何组合都适用的一个特性。

这张图展示了什么是组合：

debug - 图2
debug - 图3

这里有一个具体的例子：

  1. var g = function(x){ return x.length; };
  2. var f = function(x){ return x === 4; };
  3. var isFourLetterWord = compose(f, g);

identity 这个独特的态射

让我们介绍一个名为 id 的实用函数。这个函数接受随便什么输入然后原封不动地返回它：

  1. var id = function(x){ return x; };

你可能会问“这到底哪里有用了？”。别急，我们会在随后的章节中拓展这个函数的，暂时先把它当作一个可以替代给定值的函数——一个假装自己是普通数据的函数。

id 函数跟组合一起使用简直完美。下面这个特性对所有的一元函数（unary function）（一元函数：只接受一个参数的函数） f 都成立：

  1. // identity
  2. compose(id, f) == compose(f, id) == f;
  3. // true

嘿，这就是实数的单位元（identity property）嘛！如果这还不够清楚直白，别着急，慢慢理解它的无用性。很快我们就会到处使用 id 了，不过暂时我们还是把它当作一个替代给定值的函数。这对写 pointfree 的代码非常有用。

好了，以上就是类型和函数的范畴。不过如果你是第一次听说这些概念，我估计你还是有些迷糊，不知道范畴到底是什么，为什么有用。没关系，本书全书都在借助这些知识编写示例代码。至于现在，就在本章，本行文字中，你至少可以认为它向我们提供了有关组合的知识——比如结合律和单位律。

除了类型和函数，还有什么范畴呢？还有很多，比如我们可以定义一个有向图（directed graph），以节点为对象，以边为态射，以路径连接为组合。还可以定义一个实数类型（Number），以所有的实数为对象，以 >= 为态射（实际上任何偏序（partial order）或全序（total order）都可以成为一个范畴）。范畴的总数是无限的，但是要达到本书的目的，我们只需要关心上面定义的范畴就好了。至此我们已经大致浏览了一些表面的东西，必须要继续后面的内容了。

总结

组合像一系列管道那样把不同的函数联系在一起，数据就可以也必须在其中流动——毕竟纯函数就是输入对输出，所以打破这个链条就是不尊重输出，就会让我们的应用一无是处。

我们认为组合是高于其他所有原则的设计原则，这是因为组合让我们的代码简单而富有可读性。另外范畴学将在应用架构、模拟副作用和保证正确性方面扮演重要角色。

现在我们已经有足够的知识去进行一些实际的练习了，让我们来编写一个示例应用。

第 6 章: 示例应用

练习

  1. require('../../support');
  2. var _ = require('ramda');
  3. var accounting = require('accounting');
  5. // 示例数据
  6. var CARS = [
  7.     {name: "Ferrari FF", horsepower: 660, dollar_value: 700000, in_stock: true},
  8.     {name: "Spyker C12 Zagato", horsepower: 650, dollar_value: 648000, in_stock: false},
  9.     {name: "Jaguar XKR-S", horsepower: 550, dollar_value: 132000, in_stock: false},
  10.     {name: "Audi R8", horsepower: 525, dollar_value: 114200, in_stock: false},
  11.     {name: "Aston Martin One-77", horsepower: 750, dollar_value: 1850000, in_stock: true},
  12.     {name: "Pagani Huayra", horsepower: 700, dollar_value: 1300000, in_stock: false}
  13.   ];
  15. // 练习 1:
  16. // ============
  17. // 使用 _.compose() 重写下面这个函数。提示：_.prop() 是 curry 函数
  18. var isLastInStock = function(cars) {
  19.   var last_car = _.last(cars);
  20.   return _.prop('in_stock', last_car);
  21. };
  23. // 练习 2:
  24. // ============
  25. // 使用 _.compose()、_.prop() 和 _.head() 获取第一个 car 的 name
  26. var nameOfFirstCar = undefined;
  29. // 练习 3:
  30. // ============
  31. // 使用帮助函数 _average 重构 averageDollarValue 使之成为一个组合
  32. var _average = function(xs) { return reduce(add, 0, xs) / xs.length; }; // <- 无须改动
  34. var averageDollarValue = function(cars) {
  35.   var dollar_values = map(function(c) { return c.dollar_value; }, cars);
  36.   return _average(dollar_values);
  37. };
  40. // 练习 4:
  41. // ============
  42. // 使用 compose 写一个 sanitizeNames() 函数，返回一个下划线连接的小写字符串：例如：sanitizeNames(["Hello World"]) //=> ["hello_world"]。
  44. var _underscore = replace(/\W+/g, '_'); //<-- 无须改动，并在 sanitizeNames 中使用它
  46. var sanitizeNames = undefined;
  49. // 彩蛋 1:
  50. // ============
  51. // 使用 compose 重构 availablePrices
  53. var availablePrices = function(cars) {
  54.   var available_cars = _.filter(_.prop('in_stock'), cars);
  55.   return available_cars.map(function(x){
  56.     return accounting.formatMoney(x.dollar_value);
  57.   }).join(', ');
  58. };
  61. // 彩蛋 2:
  62. // ============
  63. // 重构使之成为 pointfree 函数。提示：可以使用 _.flip()
  65. var fastestCar = function(cars) {
  66.   var sorted = _.sortBy(function(car){ return car.horsepower }, cars);
  67.   var fastest = _.last(sorted);
  68.   return fastest.name + ' is the fastest';
  69. };