TypeScript 的并集和交集类型的命名

Question

我无法理解 TypeScript 中术语 联合类型 和 交集类型 背后的逻辑。

实际上，如果不同类型的属性是属性集，如果我将它们与 & 运算符组合，结果类型将是 union那些套。按照这个逻辑，我希望这样的类型被称为联合类型。如果我将它们与|结合起来，我只能使用它们的共同属性，集合的交集。

Wikipedia 似乎支持这个逻辑：

The power set (set of all subsets) of any given nonempty set S forms a Boolean algebra, an algebra of sets, with the two operations ∨ := ∪ (union) and ∧ := ∩ (intersection).

然而，根据typescriptlang.org，恰恰相反：&用于产生交集类型而|用于联合类型.

我确定还有另一种方式来看待它，但我想不出来。

Answer 1

类型A | B指的是A或B的对象。换句话说，这种类型的值是从 union A 的值和 B.

的值中提取的

类型A & B指的是同时A和B的对象。换句话说，这种类型的值是从 A 的值和 B.

的值的 交叉点 中提取的

命名和语义在其他语言（例如 C++）中是相同的。

Answer 2

这是另一种思考方式。考虑四组：蓝色的东西，红色的东西，大的东西，小的东西。

如果你相交所有蓝色事物和所有小事物的集合，你最终会得到属性的联合——集合中的所有东西都有蓝色属性和小属性.

但是如果你把蓝色小东西和红色小东西的联合,只有小属性在结果集中是通用的。 “蓝色小”与“红色小”相交产生“小”。

换句话说，取值域的并集会产生一组相交的属性，反之亦然。

图片形式：

Answer 3

这里的混淆可能源于我们如何想象集合，即将 intersection/union 视为涉及类型的成员而不是 自己打字。我整理了一张图表，希望能阐明这个概念：

Answer 4

在这种情况下，您不能将类型视为对象属性集。我们可以通过 looking at scalar variables 及其允许值集（而不是对象）来避免关于并集和交集类型如何工作的混淆：

type A = 1 | 2
type B = 2 | 3
type I = A & B
type U = A | B

let a: A
let b: B
let i: I
let u: U

a = 1
a = 2
a = 3 // <- error

b = 1 // <- error
b = 2
b = 3

i = 1 // <- error
i = 2
i = 3 // <- error

u = 1
u = 2
u = 3

这里的术语 "union" 和 "intersection" 与应用于允许值集合的集合论术语完全对应。

Applying the notion of permissible values (instances) to object types 有点棘手（因为集合论类比不成立）：

type A = {
  x: number
  y: number
}

type B = {
  y: number
  z: number
}

type I = A & B
type U = A | B

A 类型的变量可以保存具有属性 x 和 y（没有其他属性）的对象实例。
B 类型的变量可以保存具有属性 y 和 z（没有其他属性）的对象实例。
在集合论中，上面两组对象实例的交集是空的。但是，交集类型 I 的变量可以保存具有 A 类型属性和 B 类型属性的对象（即 x, y, 和 z; 因此 & 符号）对应于两种类型属性的 union （因此混淆） .
在集合论中，上述两组对象实例的并集不包括具有所有三个属性的对象。但是，联合类型 U 的变量可以保存具有 A 类型属性或 B 类型属性的对象（逻辑或，而非异或，即 x 和 y、y 和 z，或 x、y 和 z；因此 | 符号），这意味着两种类型的属性（在我们的示例中为 y）的交集保证存在（因此造成混淆）。

let i: I
let u: U

i = { x: 1, y: 2 };         // <- error
i = { y: 2, z: 3 };         // <- error
i = { x: 1, y: 2, z: 3 };

u = { x: 1, y: 2 };
u = { y: 2, z: 3 };
u = { x: 1, y: 2, z: 3 };

Answer 5

我也有同样的疑问，想不通怎么能反着看。看完答案后，我想我可以从语言方面进行解释，提供两个词的不同含义，并为相反的命名方法留出空间。

比较单词相交的以下含义：

The orbit of this comet intersects the orbit of the Earth.

在这句话中intersect表示在一个点或一组点交叉。想想两件事有共同点（例如一个点），但在其他方面不同。这就是数学上所谓的交集和SQL.

We need to pinpoint the place where maximum achievable conservation intersects with the highest potential financial return.

这里相交的意思是走到一起，互相影响，就像两件事成为一件很酷的新事物的组成部分。这就是 TypeScript.

中单词的含义
以类似的方式，您可以将 union 视为 一种将不同事物连接在一起的行为 在松散的意义上 - 这就是并集在数学和SQL中的含义；但它不仅可以表示 joining，还可以 joining with a common interest or purpose，这对应于 TypeScript 中 union 的含义.

受 intersect 俄语不同翻译的启发（不要问我为什么）：пересекать（也杂交）和скрещивать（也杂交）。

Answer 6

type Head = {
  skin: string, 
  bones: string, 
  nouse: number, 
  eyes: number, 
  ears: number 
}

type Body = {
  skin: string, 
  bones: string, 
  arms: number, 
  foots: number
}

type Frankenstein = Head | Body

let frank: Frankenstein

`1 rule (only Head)`

frank = {skin: 'green', bones: 'skull', nouse: 1, eyes: 2, ears: 2}

`2 rule (only Body)`

frank = {skin: 'gray', bones: 'skeleton', arms: 2, foots: 2}

`3 rule (Body and Head all together)`
 
frank = {
  skin: 'green', 
  bones: 'skull', 
  nouse: 1, 
  eyes: 2, 
  ears: 2, 
  arms: 2, 
  foots: 2
}

`4 rule (Frank without arms or foots or ears or ...)`

frank = {
  skin: 'green', 
  bones: 'skull', 
  nouse: 1, 
  eyes: 2, 
  ears: 2,
  foots: 2
 }

frank = {
  skin: 'green', 
  bones: 'skull', 
  nouse: 1, 
  eyes: 2, 
  ears: 2, 
  arms: 2
}

frank = {
  skin: 'green',
  bones: 'skull',
  nouse: 1,
  eyes: 2,
  arms: 2, 
  foots: 2
}

`-1 rule (he can't exist without general parts)`

frank = {
  bones: 'skull',
  nouse: 1,
  eyes: 2,
  ears: 2,
  foots: 2} //error

frank = {
  skin: 'green',
  nouse: 1, 
  eyes: 2,
  ears: 2,
  arms: 2} //error

`-2 rule (and the MOST NOTABLY he can not exist without full kit of one of 
his parts, why - ask his best friend - TypeScript)`

frank = {
  skin: 'green',
  bones: 'skull',
  eyes: 2,
  ears: 2,
  foots: 2} //error

frank = {
  skin: 'green',
  bones: 'skull',
  nouse: 1,
  eyes: 2,
  arms: 2
} //error

Answer 7

他们前几天刚刚更新了文档，现在它通过一个简单的例子提供了清晰的描述：

It might be confusing that a union of types appears to have the intersection of those types’ properties. This is not an accident - the name union comes from type theory. The union number | string is composed by taking the union of the values from each type. Notice that given two sets with corresponding facts about each set, only the intersection of those facts applies to the union of the sets themselves. For example, if we had a room of tall people wearing hats, and another room of Spanish speakers wearing hats, after combining those rooms, the only thing we know about every person is that they must be wearing a hat.

https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types

TypeScript 的并集和交集类型的命名

Naming of TypeScript's union and intersection types

boolean-logic

set

typescript