Javascript 为什么'；你不接受映射构造函数一个iterable元组数组吗？

我在Javascript中创建了一个元组类型，它实现了

Iterable

协议。现在，转换为

地图应该很容易：

const Tuple = (...args) => {
  const Tuple = f => f(...args);
  Tuple[Symbol.iterator] = () => args[Symbol.iterator]();
  return Tuple;
};

new Map([Tuple(1, "a"), Tuple(2, "b")]); // Map {undefined => undefined}

相反，我必须手动进行转换：


const Tuple=（…args）=>{
常量元组=f=>f（…args）；
元组[Symbol.iterator]=（）=>args[Symbol.iterator]（）；
返回元组；
};
const toArray=tx=>tx（（…args）=>args）；
常量映射=（…对）=>{
返回新映射（pairs.Map（pair=>toArray（pair））；
};
常量映射=映射（元组（1，“a”）、元组（2，“b”）；
console.log（map.get（1），map.get（2））；//“a”“b”
映射的构造函数定义为接受任何可数的键/值对象，其中键/值对象定义为属性
0
为键，属性
1
为值的对象。它没有提到允许键/值对象使用Iterables。（如果它允许他们，并定义它将调用迭代器两次，这可能会很酷，但是……他们并没有这样做。：-）而且会更复杂……）

如果我们看一下，如果您的
元组支持属性
0
（对于键）和
1
（对于值），那么它就可以工作。例如：


//（这样定义是因为您似乎想要一个非构造函数）
常量元组方法={
获取“0”（）{
返回此.key；
},
获取“1”（）{
返回此.value；
}
};
常量元组=（键，值）=>{
const t=Object.create（TupleMethods）；
t、 钥匙=钥匙；
t、 价值=价值；
返回t；
}
//用法：
常数m=新映射([
元组（“一”、“uno”），
元组（“两个”、“到期”），
元组（“三”，“三”）
]);
console.log（m.get（“两个”）；//“到期日”
const Tuple=（…args）=>Object.entries（{[args.shift（）]：args.shift（）}）；
常量映射=新映射（元组（0，“a”）.concat（元组（1，“b”））；
log（map.get（“0”）、map.get（“1”）
我在Javascript中创建了一个元组类型，它实现了
Iterable
协议

不要。元组具有独特的属性，即它们具有固定长度，每个元素都有（可以有）自己的类型，而（iterable）集合由相同类型的多个元素组成。当然，JavaScript并不关心类型（所有数组都是异构的），但作为程序员，您应该这样做

为什么
Map
只接受外部复合类型的
Iterable
，而不接受内部对

出于完全相同的原因。元素是成对的，或两个元组，表示为数组（因为缺少另一个数据结构，并且不像迭代器结果那样简单地引入一个数据结构）。它们总是正好有两个元素，可以作为
[0]
和
[1]
（它们甚至不需要
.length
！）访问，而且绝对没有理由重复它们。
每次创建
元组时创建两个函数，您支持什么设计目标？不变性；避免使用
数组
存储各种类型的相关数据（例如
[a，b]
）
Array
是一个集合，因此应该是
[a]
类型。不变性并不要求您为每个
元组创建多个函数。哦，是的，您是对的，它是church编码的。当然，不一定非要这样，“这是教堂编码的”很有趣！这很有道理。谢谢我知道元组通常是不可折叠的。我只是让它们变得可移植，这样它们就可以很好地使用
Array.from
和
Map
。然而，我不明白
Map
构造函数是如何在引擎盖下工作的。现在它有了完美的意义@ftor
Array.from
也适用于具有整数属性和
长度的对象。但是，我不明白为什么或者如何从元组创建
映射。也许我走错了路。我认为从
[（k，v）]
转换为
映射kv
，反之亦然将是一件明智的事情。但是，我对元组没有太多的经验。是的，可能是这样，我以为你指的是
新映射（元组（[k1，v1]，[k2，v2]，…）
，元组需要是可移植的。对于
Array.from（Tuple（…）
和
新映射（[Tuple（k1，v1），Tuple（k2，v2），…]）
您只需要三个属性
0
，
1
和
length
。抱歉，不是。我刚才假设“接受
Iterable
”也指内部对
[[k，v]
。但是，当这些对的结构简单明了且众所周知时，为什么要这样做呢。我将尝试为我的下一个问题提供类型签名。无论如何，我已经习惯于为我的所有函数定义它们。事实证明，当我在表达类型sigs时遇到困难时，我常常最终放弃相应的函数。它是一个很好的指示器，指示函数是否有用——即使在非类型化语言中也是如此。