javascript - 不是恒等仿函数的内仿函数的一个很好的例子是什么？

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)的数据结构，并且该 map 函数看起来应该尊重身份和组合(检查 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

因此，当我们将一个函数映射到一个仿函数(数组)上时，我们得到了同一个仿函数(一个新数组)的另一个实例，该函数应用于仿函数(数组)所持有的任何内容。

现在让我们看看另一个无处不在的 JavaScript 数据结构，即对象。没有针对对象的内置 map 函数。我们可以让他们成为仿函数吗？再次假设对象是同质的(只有一种类型的值的键，在这个例子中是数字):

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 中尽可能)支持标识和组合以满足仿函数定律。