什么是不是恒等函子的内函子的好例子？

Question

在Professor Frisby Introduces Composable Functional JavaScript中引入了恒等函子：

const Box = x => 
   ({ 
       map:  f => Box(f(x)),
       fold: f => f(x)           // for testing
   })

我花了一天的大部分时间来理解函子以及为什么上面的 JavaScript 代码实际上是恒等函子。所以我想我会改变它以获得一个不是恒等函子的“真实”函子。我想出了这个：

const Endo = x =>
   ({ 
       map:  f => Endo(f(x).split('')),
       fold: f => f(x).split('') // for testing
   })

我的理由是 Box、Id_Box: Box -> Box 和 Id_Box f = f。 Endo 也会映射到自身，但 Endo(f): Endo(x) -> Endo(y)（如果 f: x -> y）。

我走对了吗？

编辑： 将 string 替换为更通用的 x，就像在原始示例中一样。

Answer 1

正如this answer 中指出的那样，作为程序员，我们可以将所有函子视为内函子，因此不要太关注差异。

至于函子是什么，简单来说就是

1. 一种数据结构（在您的示例中为 Box）
2. 可以支持映射操作（想想Array.prototype.map）
3. 并且映射操作尊重身份：xs === xs.map(x => x)
4. ...和组合：xs.map(f).map(g) === xs.map(f . g) 其中. 是函数组合。

就是这样。不多也不少。查看您的Box，它是一个具有map 函数（检查1 和2）的数据结构，并且该映射函数看起来应该尊重身份和组合（检查3 和4）。所以它是一个函子。但它没有做任何事情，这就是为什么它是恒等函子。 fold 函数并不是绝对必要的，它只是提供了一种“打开”盒子的方法。

对于一个有用的函子，让我们看一下 JavaScript 数组。数组实际上做一些事情：即它们包含多个值而不仅仅是一个值。如果一个数组只能有一个元素，那就是你的Box。出于我们的目的，我们将假设它们只能为简单的事物保存相同类型的值。因此，数组是一种数据结构，具有映射功能，尊重身份和组合。

let plus = x => y => x + y;
let mult = x => y => x * y;
let plus2 = plus(2);
let times3 = mult(3);
let id = x => x;
let compose = (...fs) => arg => fs.reverse().reduce((x, f) => { return f(x) }, arg);  

// Here we need to stringify the arrays as JS will compare on 
// ref rather than value. I'm omitting it after the first for
// brevity, but know that it's necessary.
[1,2,3].map(plus2).toString() === [3,4,5].toString(); // true
[1,2,3].map(id) === [1,2,3]; // true
[1,2,3].map(plus2).map(times3) === [1,2,3].map(compose(times3, plus2)); // true

因此，当我们 map 一个函子（数组）上的函数时，我们会返回同一个函子（一个新数组）的另一个实例，该函数应用于函子（数组）所持有的任何内容。

现在让我们看看另一个无处不在的 JavaScript 数据结构，对象。对象没有内置的 map 函数。我们可以让它们成为函子吗？再次假设对象是同质的（只有一种类型值的键，在本例中为 Number）：

let mapOverObj = obj => f => {
  return Object.entries(obj).reduce((newObj, [key, value]) => {
    newObj[key] = f(value);
    return newObj;
  }, {});
};

let foo = { 'bar': 2 };
let fooPrime = mapOverObj(foo)(plus2); // { 'bar': 4 }

您可以继续准确地测试该函数（尽可能在 JavaScript 中）是否支持标识和组合以满足函子定律。