UnionMember: export internal type, useful to recurse union-types.

[taiyakihitotsu]

Add UnionMember

• This is useful to recurse union-types, so I think this should be exported as a global for end-users.
• We can evade a duplicated definition potentially.

And the current UnionMember, which locally defined in UnionToTuple, returns unknown.

expectType<never>({} as UnionMember<never>);
//=> unknown

This would cause an error if end-users use IsNever for termination check.

Ideally, UnionMember reduces a type, e.g., assuming $A$ and $B$ are type arguments of UnionMember<A | B>, $A \cup B$ -> $B$, so $\emptyset$ -> $\emptyset$ intuitively ($\bot$ -> $\bot$).
This PR's UnionMember handles this.

---

Note

• This PR is separated from UnionToTuple: Fix behavior when a union member is a supertype of another; Add ExcludeExactly type #1349

[taiyakihitotsu]

@sindresorhus

Thanks for your reviews!

And I believe this suggestion implies that test-d/last-of-union.ts should have a test for recursion without directly importing UnionToTuple to clarify it. Right?

If so, UnionToTuple in test-d/last-of-union.ts fulfills the requirement. Would it be okay to integrate both in test-d/last-of-union.ts?

---

#1368 (comment)

type UnionToTupleWithExclude<T, L = LastOfUnion<T>> =
	IsNever<T> extends false
		? [...UnionToTupleWithExclude<Exclude<T, L>>, L]
		: [];

expectType<1 | 2 | 3>({} as UnionToTupleWithExclude<1 | 2 | 3>[number]);

[som-sm]

Umm...I don't think this approach for testing is ideal where we implement something with LastOfUnion and then test the implementation. We'll have to find a better way.

[som-sm]

Let's just use something similar to UnionToTuple, like:

type Test<T, L = LastOfUnion<T>> =
IsNever<T> extends false
	? Test<Exclude<T, L>> | L
	: never;

expectType<1 | 2 | 3>({} as Test<1 | 2 | 3>);

Also, remove everything else. Here, we are not trying to test quirks of a specific implementation, such as Exclude behaving unexpectedly in certain cases. The goal here is to test LastOfUnion only, so the surrounding implementation should be as minimal as possible.

[som-sm]

type Test<T, L = LastOfUnion<T>> =
IsNever<T> extends false
	? Test<Exclude<T, L>> | L
	: never;

Even this is not ideal, because it does not guarantee that LastOfUnion picks exactly one member at a time. For example, in the 1 | 2 | 3 case, if LastOfUnion<1 | 2 | 3> returns 1 | 2 first, and then LastOfUnion<Exclude<1 | 2 | 3, 1 | 2>> returns 3, the test would still pass.

This is a better approach I guess:

type Test<T, L = LastOfUnion<T>> =
IsNever<T> extends false
	? Test<Exclude<T, L>> | [L]
	: never;

expectType<[1] | [2] | [3]>({} as Test<1 | 2 | 3>);

I hope this makes sense?

[taiyakihitotsu]

I kept only this definition.
#1368 (comment)

---

After both are merged, #1368 and #1349, then open a PR to fix test-d/union-member.ts to add the readonlyExcludeExactly case.
Or include the test case into #1349 (and merge this after #1368).

Does this sound acceptable?
If so, which approach do you prefer?

[taiyakihitotsu]

Sorry, our comments crossed!

Even this is not ideal, because it does not guarantee that LastOfUnion picks exactly one member at a time.

I’ve added your test case to test-d/union-member.ts and included a comment explaining the scenario it covers.

[taiyakihitotsu]

After both are merged, #1368 and #1349, then open a PR to fix test-d/union-member.ts to add the readonlyExcludeExactly case.

And I've updated this my comment, because this is NOT readonly but ExcludeExacly case.