JS函数式编程【译】5.2 函子 (Functors)

标签：

函子（Functors）

态射是类型之间的映射；函子是范畴之间的映射。可以认为函子是这样一个函数，它从一个容器中取出值， 并将其加工，然后放到一个新的容器中。这个函数的第一个输入的参数是类型的态射，第二个输入的参数是容器。

创建函子

要知道我们已经有了一个函子：map()，它攫取包含一些值的容器（数组），然后把一个函数作用于它。

[1, 4, 9].map(Math.sqrt); // Returns: [1, 2, 3]

然而我们要把它写成一个全局函数，而不是数组对象的方法。这样我们后面就可以写出简洁、安全的代码。

// map :: (a -> b) -> [a] -> [b]
var map = function(f, a) {
  return arr(a).map(func(f));
}

这个例子看起来像是个故意弄的封装，因为我们只是把map()函数换了个形式。但这有它的目的。 它为映射其它类型提供了一个模板。

// strmap :: (str -> str) -> str -> str
var strmap = function(f, s) {
  return str(s).split(‘‘).map(func(f)).join(‘‘);
}

数组和函子

数组是函数式JavaScript使用数据的最好的方式。

是否有一种简单的方法来创建已经分配了态射的函子？有，它叫做arrayOf。 当你传入一个以整数为参数、返回数组的态射时，你会得到一个以整数数组为参数返回数组的数组的态射。

它自己本身不是函子，但是它让我们能够用态射建立函子。

// arrayOf :: (a -> b) -> ([a] -> [b])
var arrayOf = function(f) {
  return function(a) {
    return map(func(f), arr(a));
  }
}

下面是如何用态射创建函子

var plusplusall = arrayOf(plusplus); // plusplus是函子
console.log( plusplusall([1,2,3]) ); // 返回[2,3,4]
console.log( plusplusall([1,‘2‘,3]) ); // 抛出错误

函数组合，重访（revisited）

函数也是一种我们能够用函子来创建的原始类型，这个函子叫做“fcompose”。我们对函子是这样定义的： 它从容器中取一个值，并对其应用一个函数。如果这个容器是一个函数，我们只需要调用它并获取里面的值。

我们已经知道了什么是函数组合，不过让我们来看看在范畴论驱动的环境里它们能做些什么。

函数组合就是结合（associative，中学数学中学到的“结合律”中的“结合”）。如果你的高中代数老师也像我这样的话那她只告诉了你函数组合的定律有什么，而没有没教你用它能做些什么。在实践中，组合就是结合律所能够做的。

我们可以任意进行内部组合，无所谓怎样分组。交换律也没有什么可迷惑的。f g 不总等于 g f。比如说，一个句子的第一个单词被反转并不等同于一个被反转的句子的第一个单词。

总的来说意思就是哪个函数以什么样的顺序被执行是无所谓的，只要每个函数的输入来源于上一个函数的输出。不过，等等，如果右边的函数依赖于左边的函数，不就是只有一个固定的求值顺序吗？从左到右？是的，如果把它封装起来，我们就可以按照我们感觉合适的方式来控制它。这就使得在JavaScript中可以实现惰性求值。

我们来重写函数组合，不作为函数原型的扩展，而是作为一个单独的函数，这样我们就可以的到更多的功能。基本的形式是这样的：

var fcompose = function(f, g) {
  return function() {
    return f.call(this, g.apply(this, arguments));
  };
};

不过我们还得让它能接受任意数量的输入。

var fcompose = function() {
  // 首先确保所有的参数都是函数
  var funcs = arrayOf(func)(arguments);  //译注：这句有问题，见下面注释
  // 返回一个作用于所有函数的函数
  return function() {
    var argsOfFuncs = arguments;
    for (var i = funcs.length; i > 0; i -= 1) {
      argsOfFuncs  = [funcs[i].apply(this, args)];
    }
    return args[0];
  };
};

// 例：
var f = fcompose(negate, square, mult2, add1);
f(2); // 返回: -36

var fcompose = function() {
  var funcs = arrayOf(func)(Array.prototype.slice.call(arguments));
  return function() {
    var args = arguments;
    for (var i = funcs.length-1; i >= 0; i -= 1) {
      args  = [funcs[i].apply(this, args)];
    }
    return args[0];
  };
};

现在我们封装好了这些函数并可以控制它们了。我们重写了组合函数使得每一个函数接受另一个函数作为输入， 存储起来，并同样返回一个对象。这里并不是接受一个数组作为输入处理它，而是对每一个操作返回一个新的数组， 我们可以在源头上让每一个元素接受一个数组，把所有操作合到一起执行（所有map、filter等等组合到一起）， 最终把结果存到一个新数组里。这就是通过函数组合实现的惰性求值。这里我们没有理由重新造轮子， 许多库对于这个概念都有很好的实现，包括Lazy.js、Bacon.js以及wu.js等库。

利用这一不同模式的结果，我们可以做更多事情：异步迭代、异步事件处理、惰性求值甚至自动并行。

JS函数式编程【译】5.2 函子 (Functors)

标签：

原文地址：http://www.cnblogs.com/tolg/p/5258029.html