Przekształć typ unii na typ przecięcia


88

Czy istnieje sposób na przekształcenie typu unii w typ przecięcia:

type FunctionUnion = () => void | (p: string) => void
type FunctionIntersection = () => void & (p: string) => void

Chciałbym zastosować transformację, FunctionUnionaby uzyskaćFunctionIntersection

Odpowiedzi:


193

Chcesz związku na skrzyżowaniu? Mogą to zrobić dystrybucyjne typy warunkowe i wnioskowanie z typów warunkowych . (Nie myśl jednak, że można zrobić skrzyżowanie do zjednoczenia, przepraszam) Oto zła magia:

type UnionToIntersection<U> = 
  (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never

To rozdziela związek Ui przepakowuje go do nowego związku, w którym wszyscy konsumenci znajdują się w kontrawariantnych pozycjach. To pozwala wywnioskować typ jako przecięcie I, jak wspomniano w podręczniku:

Podobnie, wiele kandydatów na zmienną tego samego typu na pozycjach przeciwwariantowych powoduje wywnioskowanie typu przecięcia.


Zobaczmy, czy to zadziała.

Najpierw pozwól mi umieścić w nawiasach twoje FunctionUnioni FunctionIntersectionponieważ TypeScript wydaje się wiązać związek / przecięcie ściślej niż funkcja powrotu:

type FunctionUnion = (() => void) | ((p: string) => void);
type FunctionIntersection = (() => void) & ((p: string) => void);

Testowanie:

type SynthesizedFunctionIntersection = UnionToIntersection<FunctionUnion>
// inspects as 
// type SynthesizedFunctionIntersection = (() => void) & ((p: string) => void)

Wygląda dobrze!

Należy uważać, aby ogólnie UnionToIntersection<>ujawnić pewne szczegóły tego, co TypeScript uważa za rzeczywistą unię. Na przykład booleanjest najwyraźniej wewnętrznie reprezentowany jako true | falsetak

type Weird = UnionToIntersection<string | number | boolean>

staje się

type Weird = string & number & true & false

który w TS3.6 + jest chętnie redukowany do

type Weird = never

ponieważ niemożliwe jest posiadanie wartości, która jest string i number i true i false .

Mam nadzieję, że to pomoże. Powodzenia!


14
10x. Zawsze uczę się od ciebie nowych, interesujących rzeczy. Byłem bardzo blisko tego pytania stackoverflow.com/questions/50369299/… ale naprawdę potrzebuję sposobu, aby przekształcić związek w skrzyżowanie
— Titian Cernicova-Dragomir

2
Ta odpowiedź jest niesamowita, ale naprawdę trudno mi zrozumieć, jak działa ta część „która rozprowadza związek U i przepakowuje go do nowego związku, w którym wszystkie składowe są w pozycji kontrawariantnej ” :( Nie mogę w pełni pojąć tej części dotyczącej kontrawariantnej pozycji .Myślałem, że ten kod: type Param<T> = T extends (arg: infer U) => void ? U : never; type InferredParams = Param<((a: string) => void) | ((a: number) => void)>;powinien mi dać, string & numberale mi daje string | number. Czy możesz wyjaśnić dlaczego?
— Mariusz Pawelski

10
Dzieje się tak, ponieważ parametry pierwotnego typu przed extendsw typie warunkowym są rozłożone na wszystkie składniki unii. Jeśli chcesz wyłączyć rozproszonych typów warunkowych, można użyć trick dokonywania parametr typu „ubrany”, takich jak pojedynczym elemencie krotki tak: type Param<T> = [T] extends [(arg: infer U) => void] ? U : never;. To powinno działać tak, jak chcesz.
— jcalz

3
@RanLottem kluczem są dystrybucyjne typy warunkowe . Moim zdaniem podręcznik całkiem dobrze to wyjaśnia. Mam rozszerzony na to gdzie indziej trzeba więcej informacji. Powodzenia!
— jcalz

1
@NicholasCuthbert bądź ostrożny; unknownjest „prawidłowym” wynikiem. Dla wszystkich Aa B, UTI<A | B>powinna być równa UTI<A> & UTI<B>, prawda? Niech Bbędzie neveri zwróć uwagę na A | neverto A. Teraz masz UTI<A> = UTI<A> & UTI<never>dla wszystkich A. Jedynym rozsądnym sposobem spełnienia tego warunku jest UTI<never>= unknown, ponieważ X & unknownjest równe X. Gdyby tak UTI<never>było never, UTI<A> = UTI<A> & neverale skoro X & never= never, mówisz UTI<A> = neverza wszystkich A... nie świetnie. Nie może być przypadki użycia dla UTI<never>być never, ale nie jest oczywiste dla mnie, więc należy być ostrożnym.
— jcalz

6

Istnieje również bardzo powiązany problem, gdy chcesz skrzyżować kilka typów, ale niekoniecznie konwertować związki na skrzyżowania. Po prostu nie ma sposobu, aby dostać się prosto do skrzyżowań bez uciekania się do tymczasowych związków zawodowych!

Problem polega na tym, że typy, które chcielibyśmy uzyskać, mogą mieć w środku połączenia , które również zostaną zamienione na skrzyżowania. Strażnicy na ratunek:

// union to intersection converter by @jcalz
// Intersect<{ a: 1 } | { b: 2 }> = { a: 1 } & { b: 2 }
type Intersect<T> = (T extends any ? ((x: T) => 0) : never) extends ((x: infer R) => 0) ? R : never

// get keys of tuple
// TupleKeys<[string, string, string]> = 0 | 1 | 2
type TupleKeys<T extends any[]> = Exclude<keyof T, keyof []>

// apply { foo: ... } to every type in tuple
// Foo<[1, 2]> = { 0: { foo: 1 }, 1: { foo: 2 } }
type Foo<T extends any[]> = {
    [K in TupleKeys<T>]: {foo: T[K]}
}

// get union of field types of an object (another answer by @jcalz again, I guess)
// Values<{ a: string, b: number }> = string | number
type Values<T> = T[keyof T]

// TS won't believe the result will always have a field "foo"
// so we have to check for it with a conditional first
type Unfoo<T> = T extends { foo: any } ? T["foo"] : never

// combine three helpers to get an intersection of all the item types
type IntersectItems<T extends any[]> = Unfoo<Intersect<Values<Foo<T>>>>

type Test = [
    { a: 1 } | { b: 2 },
    { c: 3 },
]

// this is what we wanted
type X = IntersectItems<Test> // { a: 1, c: 3 } | { b: 2, c: 3 }

// this is not what we wanted
type Y = Intersect<Test[number]> // { a: 1, b: 2, c: 3 }

Wykonanie w podanym przykładzie wygląda następująco

IntersectItems<[{ a: 1 } | { b: 2 }, { c: 3 }]> =
Unfoo<Intersect<Values<Foo<[{ a: 1 } | { b: 2 }, { c: 3 }]>>>> =
Unfoo<Intersect<Values<{0: { foo: { a: 1 } | { b: 2 } }, 1: { foo: { c: 3 } }}>>> =
Unfoo<Intersect<{ foo: { a: 1 } | { b: 2 } } | { foo: { c: 3 } }>> =
Unfoo<(({ foo: { a: 1 } | { b: 2 } } | { foo: { c: 3 } }) extends any ? ((x: T) => 0) : never) extends ((x: infer R) => 0) ? R : never> =
Unfoo<(({ foo: { a: 1 } | { b: 2 } } extends any ? ((x: T) => 0) : never) | ({ foo: { c: 3 } } extends any ? ((x: T) => 0) : never)) extends ((x: infer R) => 0) ? R : never> =
Unfoo<(((x: { foo: { a: 1 } | { b: 2 } }) => 0) | ((x: { foo: { c: 3 } }) => 0)) extends ((x: infer R) => 0) ? R : never> =
Unfoo<{ foo: { a: 1 } | { b: 2 } } & { foo: { c: 3 } }> =
({ foo: { a: 1 } | { b: 2 } } & { foo: { c: 3 } })["foo"] =
({ a: 1 } | { b: 2 }) & { c: 3 } =
{ a: 1 } & { c: 3 } | { b: 2 } & { c: 3 }

Mam nadzieję, że pokazuje to również inne przydatne techniki.

Korzystając z naszej strony potwierdzasz, że przeczytałeś(-aś) i rozumiesz nasze zasady używania plików cookie i zasady ochrony prywatności.
Licensed under cc by-sa 3.0 with attribution required.