730 - Union to Tuple

[uid11]

TS Playground.

/**
 * UnionToIntersection<{ foo: string } | { bar: string }> =
 *  { foo: string } & { bar: string }.
 */
type UnionToIntersection<U> = (
  U extends unknown ? (arg: U) => 0 : never
) extends (arg: infer I) => 0
  ? I
  : never;

/**
 * LastInUnion<1 | 2> = 2.
 */
type LastInUnion<U> = UnionToIntersection<
  U extends unknown ? (x: U) => 0 : never
> extends (x: infer L) => 0
  ? L
  : never;

/**
 * UnionToTuple<1 | 2> = [1, 2].
 */
type UnionToTuple<U, Last = LastInUnion<U>> = [U] extends [never]
  ? []
  : [...UnionToTuple<Exclude<U, Last>>, Last];

[xianshenglu]

Could you please add some explanation for the questions below?

type h = ((x: 1) => 0) & ((x: 2) => 0) //why h not never

type e = (((x: 1) => 0) & ((x: 2) => 0)) extends (x: infer L) => 0 ? L : never; //  why e is 2 not never or 1?

It stops me from understanding the answer.

[uid11]

type h = ((x: 1) => 0) & ((x: 2) => 0) //why h not never

Function arguments are in contravariant positions, so when functions intersect, arguments do not intersect, but are united.
This intersection of functions forms an overload -- a function that takes either 1 or 2 as its first argument.

type e = (((x: 1) => 0) & ((x: 2) => 0)) extends (x: infer L) => 0 ? L : never; //  why e is 2 not never or 1?

This is a feature of TS, mentioned somewhere in the documentation -- if it is necessary to output one type from overload, TS selects the last signature ((x: 2) => 0) in the overload.

[xianshenglu]

Thanks so much!

[zojize]

I was just fiddling around with this question and came up with an answer that 'worked' but really shouldn't have 😂

type UnionToTuple<T> = { [P in T as string]: [P] }[string];

[Jayatubi]

type h = ((x: 1) => 0) & ((x: 2) => 0) //why h not never

Function arguments are in contravariant positions, so when functions intersect, arguments do not intersect, but are united.
This intersection of functions forms an overload -- a function that takes either 1 or 2 as its first argument.

type e = (((x: 1) => 0) & ((x: 2) => 0)) extends (x: infer L) => 0 ? L : never; //  why e is 2 not never or 1?

This is a feature of TS, mentioned somewhere in the documentation -- if it is necessary to output one type from overload, TS selects the last signature ((x: 2) => 0) in the overload.

If I understand correctly the idea was to first convert union to intersection, and then extract the last element from intersection by the function overloading feature?

[edisonLzy]

This is a feature of TS, mentioned somewhere in the documentation -- if it is necessary to output one type from overload, TS selects the last signature ((x: 2) => 0) in the overload.

so where's the mentioned in the documentation ?

[plneple]

  Steps to easier understand this:

  UnionToTuple<'a' | 'b'>
  |  LastInUnion<'a' | 'b'>
  |  |  UnionToIntersection<((x: 'a') => 0) | ((x: 'b') => 0)>
  |  |  | Why: CONTRA-VARIANT position (function overload)
  |  |  Resolve to ((x: 'a') => 0) & ((x: 'b') => 0)
  |  | infer L -> gets 'b' because it's last overload
  |  | DOC: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-8.html
  |  Resolve to 'b'
  |  UnionToTuple<'a'>
  |  |  LastInUnion<'a'>
  |  |  |   UnionToIntersection<(x: 'a') => 0>
  |  |  |   |
  |  |  |   Resolve to (x: 'a') => 0
  |  |  | infer L -> 'a'
  |  |  Resolve to 'a'
  |  |  UnionToTuple<never>
  |  |  |
  |  |  Resolve to []
  |  Resolve to [...[], 'a'], so ['a']
  Resolve to [...['a'], 'b'], so ['a', 'b']

  Success :)

[Alexsey]

Thanks to everyone for the explanations!

Still, there is one thing that remains unclear:

intersection of functions forms an overload

Where has this been specified?

I think it's the first time I see where in TS overloads are getting somehow connected to the rest of the type system. In a very unobvious and unsound way - A & B appeared to be not the same as B & A!

UPD: It looks like it is indirectly mentioned in the docs here:

When inferring from a type with multiple call signatures (such as the type of an overloaded function), inferences are made from the last signature (which, presumably, is the most permissive catch-all case). It is not possible to perform overload resolution based on a list of argument types.

Where "type with multiple call signatures" also means functions intersection

[dimitropoulos]

Something changed after TypeScript 2.8 (the doc being mentioned above). The last line isn't string & number as it was at the time, it's never today (I'm in 4.9). Not sure when this changed.

[dimitropoulos]

And to add to what @Alexsey said it does seem that through the method found in this solution you can create a scenario where union/intersection order matters:

[Alexsey]

Something changed after TypeScript 2.8 (the doc being mentioned above). The last line isn't string & number as it was at the time, it's never today (I'm in 4.9). Not sure when this changed.

TS didn't change - string & number was always never 😄 It could have been changed the way types are represented in the editor (it may not have been collapsing it to never in "view" mode), but probably it's more of a comment in the doc to show that never is coming from string & number

[dimitropoulos]

ohhh ok. I was just confused because the docs say string & number, but I see now what you mean is that they may have been trying to convey (by implication) that that's never. wow. great. thanks for explaining!!