update: refine ExcludeExactly, update test-cases.

Co-authored-by: Som Shekhar Mukherjee <49264891+som-sm@users.noreply.github.com>

Author: taiyakihitotsu

source/exclude-exactly.d.ts

@@ -1,69 +1,7 @@
-import type {IsUnknown} from './is-unknown.d.ts';
 import type {IsNever} from './is-never.d.ts';
 import type {IsAny} from './is-any.d.ts';
-import type {LastOfUnion} from './last-of-union.d.ts';
-
-/**
-Return `never` if the first and second arguments are identical.
-Return the first argument if not.
-(But there's a limitation about union/intersection type. See `IsEqual` in `source/is-equal.d.ts`.)
-
-@example
-```
-type A = MatchOrNever<string | number, string>;
-//=> string | number
-type B = MatchOrNever<string | number, string | number>;
-//=> never
-type C = MatchOrNever<string | number, unknown>;
-//=> string | number
-type D = MatchOrNever<string, string | number>;
-//=> string
-```
-
-This does NOT depend on assignability.
-
-@example
-```
-type RO_0 = MatchOrNever<{readonly a: 0}, {a: 0}>;
-//=> {readonly a: 0}
-type RO_1 = MatchOrNever<{a: 0}, {readonly a: 0}>;
-//=> {a: 0}
-```
-
-`unknown` and `never` cases, which easily break equality in type-level codebase.
-
-@example
-```
-type E = MatchOrNever<unknown, never>;
-//=> unknown
-type F = MatchOrNever<unknown, unknown>;
-//=> never
-type G = MatchOrNever<never, never>;
-//=> never
-type H = MatchOrNever<never, unknown>;
-//=> never
-```
-
-Note that this doesn't regard the identical union/intersection type `T | T` and/or `T & T` as `T` recursively.
-e.g., `{a: 0} | {a: 0}` and/or `{a: 0} & {a: 0}` as `{a: 0}`.
-
-@example
-```
-type IDUnion = MatchOrNever<{a: {b: 0}} | {a: {b: 0}}, {a: {b: 0}}>;
-//=> never
-type A = {a: {b: 0} | {b: 0}};
-type RecurivelyIDUnion = MatchOrNever<A, {a: {b: 0}}>;
-//=> A
-```
-*/
-type MatchOrNever<A, B> =
-	[unknown, B] extends [A, never]
-		? A
-		// This equality code base below doesn't work if `A` is `unknown` and `B` is `never` case.
-		// So this branch should be wrapped to take care of this.
-		: (<G>() => G extends A & G | G ? 1 : 2) extends (<G>() => G extends B & G | G ? 1 : 2)
-			? never
-			: A;
+import type {If} from './if.d.ts';
+import type {IfNotAnyOrNever} from './internal/type.d.ts';
 
 /**
 A stricter version of `Exclude<T, U>` that ensures objects with different key modifiers are not considered identical.
@@ -106,19 +44,32 @@ type ExcludeFromUnknownArray = ExcludeExactly<number[] | unknown[], number[]>;
 
 @category Improved Built-in
 */
-export type ExcludeExactly<UnionU, DeleteT> =
-	LastOfUnion<DeleteT> extends infer D
-		? true extends IsNever<D>
-			? UnionU
-			: ExcludeExactly<_ExcludeExactly<UnionU, D>, _ExcludeExactly<DeleteT, D>>
-		: never;
+export type ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<
+		Union,
+		_ExcludeExactly<Union, Delete>,
+		// If `Union` is `any`, then if `Delete` is `any`, return `never`, else return `Union`.
+		If<IsAny<Delete>, never, Union>,
+		// If `Union` is `never`, then if `Delete` is `never`, return `never`, else return `Union`.
+		If<IsNever<Delete>, never, Union>
+	>;
+
+type _ExcludeExactly<Union, Delete> =
+	IfNotAnyOrNever<Delete,
+		Union extends unknown // For distributing `Union`
+			? [Delete extends unknown // For distributing `Delete`
+				? If<SimpleIsEqual<Union, Delete>, true, never>
+				: never] extends [never] ? Union : never
+			: never,
+		// If `Delete` is `any` or `never`, then return `Union`,
+		// because `Union` cannot be `any` or `never` here.
+		Union, Union
+	>;
+
+type SimpleIsEqual<A, B> =
+	(<G>() => G extends A & G | G ? 1 : 2) extends
+	(<G>() => G extends B & G | G ? 1 : 2)
+		? true
+		: false;
 
-type _ExcludeExactly<UnionU, DeleteT> =
-	true extends IsAny<DeleteT>
-		? never
-		: true extends IsUnknown<DeleteT>
-			? never
-			: UnionU extends unknown // Only for union distribution.
-				? MatchOrNever<UnionU, DeleteT>
-				: never;
 export {};

test-d/exclude-exactly.ts

@@ -3,6 +3,7 @@ import type {ExcludeExactly} from '../index.d.ts';
 
 expectType<number>({} as ExcludeExactly<0 | 1 | number, '1'>);
 expectType<never>({} as ExcludeExactly<0 | 1 | number, number>);
+expectType<0>({} as ExcludeExactly<0, number>);
 expectType<string>({} as ExcludeExactly<'0' | '1' | string, '1'>);
 expectType<never>({} as ExcludeExactly<'0' | '1' | string, string>);
 
@@ -22,15 +23,13 @@ expectType<unknown[]>({} as ExcludeExactly<unknown[], number[]>);
 expectType<{a: unknown}>({} as ExcludeExactly<{a: unknown}, {a: number}>);
 expectType<unknown[]>({} as ExcludeExactly<number[] | unknown[], number[]>);
 
-// `unknown` and `any` exclude themselves.
+// `unknown` excludes `unknown`, `any` excludes `any`.
 expectType<never>({} as ExcludeExactly<unknown, unknown>);
-expectType<never>({} as ExcludeExactly<unknown, any>);
+expectType<unknown>({} as ExcludeExactly<unknown, any>);
 expectType<never>({} as ExcludeExactly<any, any>);
-expectType<never>({} as ExcludeExactly<any, unknown>);
-
-// `unknown` and `any` exclude other types.
-expectType<never>({} as ExcludeExactly<string | number, unknown>);
-expectType<never>({} as ExcludeExactly<string | number, any>);
+expectType<any>({} as ExcludeExactly<any, unknown>);
+expectType<string | number>({} as ExcludeExactly<string | number, unknown>);
+expectType<string | number>({} as ExcludeExactly<string | number, any>);
 
 // Union
 expectType<2>({} as ExcludeExactly<0 | 1 | 2, 0 | 1>);