Nazewnictwo typów Unii i przecięć maszynopisu

Typ A | B odnosi się do obiektów, które są albo A lub B. Innymi słowy, wartości tego typu są pobierane z Unii wartości dla A i wartości dla B.

Typ A & B odnosi się do obiektów, które są zarówno A i B. Innymi słowy, wartości tego typu są pobierane z przecięcia wartości dla A i wartości dla B.

Nazewnictwo i semantyka są identyczne w innych językach, takich jak C++.

Zamieszanie tutaj prawdopodobnie wynika z tego, jak wyobrażamy sobie zbiory, a mianowicie myślenie o przecięciu / zjednoczeniu jako obejmującym członkówtypów, w przeciwieństwie do samych typów. Przygotowałem wykres, który, mam nadzieję, wyjaśni tę koncepcję:

Nie wolno w tym przypadku myśleć o typach jako o zestawach właściwości obiektów. Możemy uniknąć zamieszania o tym, jak działają typy union i przecięcia, patrząc na zmienne skalarne i ich zestawy dopuszczalnych wartości (zamiast obiektów):

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

Tutaj pojęcia "związek " i" przecięcie " odpowiadają dokładnie pojęciom teorii mnogości, gdy są stosowane do zbiorów dopuszczalnych wartości.

Zastosowanie pojęcia wartości dopuszczalnych (instancji) do obiektu typy jest nieco trudniejsze (ponieważ analogia teorii mnogości nie trzyma się dobrze):

type A = {
  x: number
  y: number
}

type B = {
  y: number
  z: number
}

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

• zmienna typu {[3] } może przechowywać instancje obiektów o właściwościach x i y (i żadnych innych właściwości).
• zmienna typu {[6] } może przechowywać instancje obiektów o właściwościach y i z (i żadnych innych właściwości).
• w teorii mnogości przecięcie dwóch zbiorów intencji obiektów powyżej jest puste. Jednak zmienna typu I can przechowuj obiekty o właściwościach typu A oraz o właściwościach typu B (tj. x, y, i z; stąd symbol &), który odpowiada Związkowi właściwości obu typów (stąd zamieszanie).
• w teorii mnogości związek dwóch zbiorów intancji obiektów nie obejmuje obiektów o wszystkich trzech właściwościach. Jednak zmienna typu union U może przechowywać obiekty o właściwościach typu A lub typu B (logiczne lub, nie XOR, tzn. x i y, y i z, lub x, y, i z; stąd symbol |), który implikuje, że przecięcie właściwości dwóch typów (y w naszym przykładzie) jest gwarantowane (stąd zamieszanie).

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 };

type A = {
  a: number
  b: number
}

type B = {
  b: number
  c: number
}

type C = A & B
type D = A | B

let a: A = { a: 2, b: 2 };
let b: B = { b: 2, c: 2 };

// intersection, narrow down, fewer options, like and, c have to match A and B
let c1: C = { a: 2, b: 2 }; // <- error
let c2: C = { b: 2, c: 2 }; // <- error
let c3: C = { a: 2, b: 2, c: 2 };

// union, broaden, more options, like or, d can match A or match B or match A and B
let d1: D = { a: 2, b: 2 };
let d2: D = { b: 2, c: 2 };
let d3: D = { a: 2, b: 2, c: 2 };

TypeScript playground click here .

Ja też miałem to samo pytanie i nie mogłem zrozumieć, jak można to zobaczyć w odwrotny sposób. Po przeczytaniu odpowiedzi, myślę, że mógłbym to wyjaśnić w aspekcie językowym, podając różne znaczenia tych dwóch słów i dając miejsce dla przeciwnych podejść nazewniczych.

Porównaj następujące znaczenia słowa intersect :

Orbita tej komety przecina orbitę Ziemi.

W tym zdaniu intersect oznacza krzyżować w punkcie lub zbiorze punktów . Pomyśl o dwóch rzeczach mających coś wspólnego (np. punkt), a poza tym różnych. To się nazywa skrzyżowanie w matematyce i SQL.

Musimy wskazać miejsce, w którym maksymalna osiągalna Ochrona krzyżuje się z najwyższym potencjalnym zyskiem finansowym.

Tutaj intersect oznaczaaby połączyć się i mieć wpływ na siebie , Jak dwie rzeczy stają się składnikami jednej nowej fajnej rzeczy. To Znaczenie słowa w maszynopisie .

W podobny sposób można myśleć o union jako akt łączenia różnych rzeczy razem w luźnym znaczeniu - to jest znaczenie union w matematyce i SQL; ale może to oznaczać nie tylko łączenie, ale łączenie ze wspólnym interesem lub celem, które odpowiada znaczeniu union w maszynopisie 16]}.

Zainspirowany (nie pytaj mnie dlaczego) przez różne tłumaczenia przecinają na język rosyjski: пересекать (także krzyżować ) i скрещивать (także krzyżować).

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