type-plus 8.0.0-beta.6 → 8.0.0-beta.8

package/src/equal/equal.ts

@@ -1,130 +1,348 @@
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection, $Then } from '../$type/branch/$selection.js'
+import type { $Distributive } from '../$type/distributive/$distributive.js'
+import type { $Any } from '../$type/special/$any.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
 import type { IsAny } from '../any/is_any.js'
+import type { And, Or } from '../logical/logical.js'
 import type { IsNever } from '../never/is_never.js'
 import type { IsObject } from '../object/is_object.js'
 import type { Properties } from '../object/properties.js'
-import type { And, Or } from '../predicates/logical.js'
-import type { IsSymbol } from '../symbol/is_symbol.js'
-import type { IdentityEqual } from './identity_equal.js'
-
-type BothNever<A, B, Both, One, None> = And<IsNever<A>, IsNever<B>, Both, Or<IsNever<A>, IsNever<B>, One, None>>
-
-type BothAny<A, B, Both, One, None> = And<IsAny<A>, IsAny<B>, Both, Or<IsAny<A>, IsAny<B>, One, None>>
+import type { Assignable } from '../predicates/assignable.js'
+import type { IsEqual } from './is_equal.js'
 
 /**
- * Checks `A` and `B` are equal.
+ * 🎭 *predicate*
  *
- * ```ts
- * type R = IsEqual<1, 1> // true
- * type R = IsEqual<any, any> // true
- * type R = IsEqual<boolean, boolean> // true
- * type R = IsEqual<true, true> // true
- * type R = IsEqual<[1], [1]> // true
- *
- * type R = IsEqual<boolean, true> // false
- * type R = IsEqual<any, 1> // false
- * type R = IsEqual<[any], [1]> // false
- * type R = IsEqual<{ a: 1 }, { a: 1; b: 2 }> // false
- * ```
+ * Validate `A` and `B` are "equal".
  *
  * Note that intersection type checks only works at first level.
  * It cannot be check recursively,
  * or else will run into infinite recursion if the type includes recursive types.
+ *
+ * @example
+ * ```ts
+ * type R = Equal<undefined, undefined> // true
+ *
+ * type R = Equal<never, undefined> // false
+ * type R = Equal<unknown, undefined> // false
+ * type R = Equal<string | boolean, undefined> // false
+ *
+ * type R = Equal<string | undefined, undefined> // boolean
+ * ```
+ *
+ * 🔱 **branching**
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = Equal<undefined, undefined, Equal.$Branch> // $Then
+ * type R = Equal<string, undefined, Equal.$Branch> // $Else
+ * ```
  */
-export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
+export type Equal<A, B, $O extends Equal.$Options = {}> = [A, B] extends [B, A]
 	? BothNever<
 			A,
 			B,
-			Then,
-			Else,
+			$ResolveBranch<$O, [$Then]>,
+			$ResolveBranch<$O, [$Else]>,
 			BothAny<
 				A,
 				B,
-				Then,
-				Else,
-				IdentityEqual<
+				$ResolveBranch<$O, [$Then]>,
+				$ResolveBranch<$O, [$Else]>,
+				Equal.$Same<
 					A,
 					B,
-					Then,
-					And<
-						IsObject<A>,
-						IsObject<B>,
-						IdentityEqual<
-							Properties<A>,
-							Properties<B>,
-							[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
-								? IsEqual<P1, P2, Then, Else>
-								: Then,
-							Else
-						>,
-						// `A` and `B` are narrowed, need to check again.
-						// This is fixed in TS 5.0.2, but keeping it to support older versions.
-						[A, B] extends [B, A] ? Then : Else
-					>
+					{
+						$then: $ResolveBranch<$O, [$Then]>
+						$else: [IsObject<A>, IsObject<B>] extends [true, true]
+							? Equal.$Same<
+									Properties<A>,
+									Properties<B>,
+									{
+										$then: [A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+											? IsEqual<P1, P2, $ResolveBranch<$O, [$Then]>, $ResolveBranch<$O, [$Else]>>
+											: $ResolveBranch<$O, [$Then]>
+										$else: $ResolveBranch<$O, [$Else]>
+									}
+								>
+							: // `A` and `B` are narrowed, need to check again.
+								// This is fixed in TS 5.0.2, but keeping it to support older versions.
+								[A, B] extends [B, A]
+								? $ResolveBranch<$O, [$Then]>
+								: $ResolveBranch<$O, [$Else]>
+					}
 				>
 			>
 		>
-	: And<IsSymbol<A, { distributive: false }>, IsSymbol<B, { distributive: false }>, Then, Else>
+	: $ResolveBranch<$O, [$Else], A>
+
+type BothNever<A, B, Both, One, None> = And<
+	IsNever<A>,
+	IsNever<B>,
+	{
+		$then: Both
+		$else: Or<
+			IsNever<A>,
+			IsNever<B>,
+			{
+				$then: One
+				$else: None
+			}
+		>
+	}
+>
+
+type BothAny<A, B, Both, One, None> = And<
+	IsAny<A>,
+	IsAny<B>,
+	{
+		$then: Both
+		$else: Or<
+			IsAny<A>,
+			IsAny<B>,
+			{
+				$then: One
+				$else: None
+			}
+		>
+	}
+>
+// export type Equal<A, B, $O extends Equal.$Options = {}> = [
+// 	$Special<A, $Special.Branch>,
+// 	$Special<B, $Special.Branch>,
+// ] extends [infer $A, infer $B]
+// 	? [$A, $B] extends [$B, $A]
+// 		? $A extends $Else
+// 			? // Both `$A` and `$B` are non-special types.
+// 			[IsObject.$<A, IsObject.$Branch>, IsObject.$<B, IsObject.$Branch>] extends [$Then, $Then]
+// 			? Equal.$Same<
+// 			Properties<A>,
+// 			Properties<B>,
+// 			{
+// 				$then: [A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+// 				? Equal<P1, P2, $O>
+// 				: $ResolveBranch<A, $O, [$Then]>,
+// 				$else: $ResolveBranch<A, $O, [$Else]>
+// 			}>: [A, B] extends [B, A] ?
+// 			$ResolveBranch<A, $O, [$Then]>:
+// 			$ResolveBranch<A, $O, [$Else]>
+// 				// Equal.$Same<
+// 				// 	Equal.$ToProps<A>,
+// 				// 	Equal.$ToProps<B>,
+// 				// 	{
+// 				// 		$then: $ResolveBranch<A, $O, [$Then]>
+// 				// 		$else: $ResolveBranch<A, $O, [$Else]>
+// 				// 	}
+// 				// >
+// 			: $ResolveBranch<A, $O, [$Then]>
+// 		: $ResolveBranch<A, $O, [$Else]>
+// 	: $InferError<'Unable to infer type of $A or $B'>
+
+export namespace Equal {
+	export type $Options = $Selection.$BaseOptions
+	export type $Default = $Selection.Predicate
+	export type $Branch = $Selection.Branch
+
+	export type _ExactEqualDistributive<T, U, $O extends $Options> = T extends U
+		? U extends T
+			? $ResolveBranch<$O, [$Then], T>
+			: $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Else]>
+	export type _ExactEqualNonDistributive<T, U, $O extends $Options> = [T, U] extends [U, T]
+		? $ResolveBranch<$O, [$Then], T>
+		: $ResolveBranch<$O, [$Else]>
+
+	/**
+	 * 🎭 *predicate*
+	 *
+	 * Validate `A` and `B` are identically equal.
+	 */
+	export type $Same<A, B, $O extends $Options> = (<_>() => _ extends (A & _) | _ ? 1 : 2) extends <_>() => _ extends
+		| (B & _)
+		| _
+		? 1
+		: 2
+		? $O['$then']
+		: $O['$else']
+
+	export type $ToProps<T> = Assignable.$<
+		object,
+		T,
+		{
+			$then: T & Properties<T>
+			$else: T & Properties<T>
+		}
+	>
+
+	// export type $ToProps<T> = T extends (...args: infer A) => infer R
+	// 	? T extends ((...args: A) => R) & infer U
+	// 		? [unknown] extends [U]
+	// 			? T
+	// 			: Properties<U>
+	// 		: 1
+	// 	: T extends Function & infer U
+	// 		? [unknown] extends [U]
+	// 			? T
+	// 			: Properties<U>
+	// 		: T extends any[]
+	// 			? [T] extends [T[0][] & infer U]
+	// 				? [unknown] extends [U]
+	// 					? T
+	// 					: T[0][] & Properties<U>
+	// 				: $InferError<'Cannot infer extra properties from Array'>
+	// 			: Properties<T>
+}
 
 /**
- * Checks `A` and `B` are not equal.
+ * 🎭 *predicate*
+ * ㊙️ *internal*
  *
+ * Validate if `T` is `U`.
+ *
+ * @example
  * ```ts
- * type R = IsNotEqual<1, 1> // false
- * type R = IsNotEqual<any, any> // false
- * type R = IsNotEqual<boolean, boolean> // false
- * type R = IsNotEqual<true, true> // false
- * type R = IsNotEqual<[1], [1]> // false
- *
- * type R = IsNotEqual<boolean, true> // true
- * type R = IsNotEqual<any, 1> // true
- * type R = IsNotEqual<[any], [1]> // true
- * type R = IsNotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * type R = $SelectInvert<undefined, undefined> // true
+ *
+ * type R = $SelectInvert<never, undefined> // false
+ * type R = $SelectInvert<unknown, undefined> // false
+ * type R = $SelectInvert<string | boolean, undefined> // false
+ *
+ * type R = $SelectInvert<string | undefined, undefined> // boolean
  * ```
  *
- * Note that intersection type checks only works at first level.
- * It cannot be check recursively,
- * or else will run into infinite recursion if the type includes recursive types.
- */
-export type IsNotEqual<A, B, Then = true, Else = false> = IsEqual<A, B, Else, Then>
-
-/**
- * Checks `A` and `B` are equal.
+ * 🔢 *customize*
  *
- * @deprecated this will be changed to `filter` variant in the future.
- * Please use `IsEqual` for the `predicate` behavior.
+ * Filter to ensure `T` is `U`, otherwise returns `never`.
  *
+ * @example
  * ```ts
- * type R = Equal<1, 1> // true
- * type R = Equal<any, any> // true
- * type R = Equal<boolean, boolean> // true
- * type R = Equal<true, true> // true
- * type R = Equal<[1], [1]> // true
- *
- * type R = Equal<boolean, true> // false
- * type R = Equal<any, 1> // false
- * type R = Equal<[any], [1]> // false
- * type R = Equal<{ a: 1 }, { a: 1; b: 2 }> // false
+ * type R = $SelectInvert<undefined, undefined, { selection: 'filter' }> // undefined
+ *
+ * type R = $SelectInvert<never, undefined, { selection: 'filter' }> // never
+ * type R = $SelectInvert<unknown, undefined, { selection: 'filter' }> // never
+ * type R = $SelectInvert<string | boolean, undefined, { selection: 'filter' }> // never
+ *
+ * type R = $SelectInvert<string | undefined, undefined> // undefined
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = $SelectInvert<undefined | 1, undefined> // boolean
+ * type R = $SelectInvert<undefined | 1, undefined, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = $SelectInvert<undefined, undefined, $SelectionBranch> // $Then
+ * type R = $SelectInvert<string, undefined, $SelectionBranch> // $Else
  * ```
  */
-export type Equal<A, B, Then = true, Else = false> = IsEqual<A, B, Then, Else>
+export type $SelectInvert<T, U, $O extends $SelectInvert.$Options = {}> = $Special<
+	T,
+	{
+		$any: $ResolveBranch<$O, [$Any, $Then], T>
+		$never: $ResolveBranch<$O, [$Never, $Then], T>
+		$unknown: $ResolveBranch<$O, [$Unknown, $Then], T>
+		$void: $ResolveBranch<$O, [$Void, $Then], T>
+		$else: $Distributive.Parse<$O> extends true ? $SelectInvert._D<T, U, $O> : $SelectInvert._N<T, U, $O>
+	}
+>
+
+export namespace $SelectInvert {
+	export type $Options = $Selection.Options & $Distributive.Options & $InputOptions<$Any | $Unknown | $Never>
+	export type $Default = $Selection.Predicate & $Distributive.Default
+	export type $Branch = $Selection.Branch & $Distributive.Default
+	export type _D<T, U, $O extends $SelectInvert.$Options> = T extends U
+		? $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
+	export type _N<T, U, $O extends $SelectInvert.$Options> = [T] extends [U]
+		? $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
+}
 
 /**
- * Checks `A` and `B` are not equal.
+ * 🎭 *predicate*
+ * ㊙️ *internal*
+ *
+ * Validate if `T` is `U`.
+ *
+ * @example
+ * ```ts
+ * type R = $SelectInvertStrict<undefined, undefined> // true
+ *
+ * type R = $SelectInvertStrict<never, undefined> // false
+ * type R = $SelectInvertStrict<unknown, undefined> // false
+ * type R = $SelectInvertStrict<string | boolean, undefined> // false
  *
- * @deprecated this will be changed to `filter` variant in the future.
- * Please use `IsNotEqual` for the `predicate` behavior.
+ * type R = $SelectInvertStrict<string | undefined, undefined> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `U`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = $SelectInvertStrict<undefined, undefined, { selection: 'filter' }> // undefined
+ *
+ * type R = $SelectInvertStrict<never, undefined, { selection: 'filter' }> // never
+ * type R = $SelectInvertStrict<unknown, undefined, { selection: 'filter' }> // never
+ * type R = $SelectInvertStrict<string | boolean, undefined, { selection: 'filter' }> // never
+ *
+ * type R = $SelectInvertStrict<string | undefined, undefined> // undefined
+ * ```
  *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = $SelectInvertStrict<undefined | 1, undefined> // boolean
+ * type R = $SelectInvertStrict<undefined | 1, undefined, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
  * ```ts
- * type R = NotEqual<1, 1> // false
- * type R = NotEqual<any, any> // false
- * type R = NotEqual<boolean, boolean> // false
- * type R = NotEqual<true, true> // false
- * type R = NotEqual<[1], [1]> // false
- *
- * type R = NotEqual<boolean, true> // true
- * type R = NotEqual<any, 1> // true
- * type R = NotEqual<[any], [1]> // true
- * type R = NotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * type R = $SelectInvertStrict<undefined, undefined, $SelectionBranch> // $Then
+ * type R = $SelectInvertStrict<string, undefined, $SelectionBranch> // $Else
  * ```
  */
-export type NotEqual<A, B, Then = true, Else = false> = IsNotEqual<A, B, Then, Else>
+export type $SelectInvertStrict<T, U, $O extends $SelectInvertStrict.$Options = {}> = $Special<
+	T,
+	{
+		$any: $ResolveBranch<$O, [$Any, $Then], T>
+		$unknown: $ResolveBranch<$O, [$Unknown, $Then], T>
+		$never: $ResolveBranch<$O, [$Never, $Then], T>
+		$else: $Distributive.Parse<$O> extends true ? $SelectInvertStrict._D<T, U, $O> : $SelectInvertStrict._N<T, U, $O>
+	}
+>
+
+export namespace $SelectInvertStrict {
+	export type $Options = $Selection.Options & $Distributive.Options & $InputOptions<$Any | $Unknown | $Never>
+	export type $Default = $Selection.Predicate & $Distributive.Default
+	export type $Branch = $Selection.Branch & $Distributive.Default
+	export type _D<T, U, $O extends $SelectInvertStrict.$Options> = T extends U
+		? $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
+	export type _N<T, U, $O extends $SelectInvertStrict.$Options> = [T, U] extends [U, T]
+		? $ResolveBranch<$O, [$Else]>
+		: $ResolveBranch<$O, [$Then], T>
+}

package/src/equal/identity_equal.ts

@@ -1,11 +1,7 @@
+import type { Equal } from './equal.js'
+
 /**
  * This is a common equal check.
  * It is good for some basic cases, but not for all.
  */
-export type IdentityEqual<A, B, Then, Else> = (<_>() => _ extends (A & _) | _ ? 1 : 2) extends <_>() => _ extends
-	| (B & _)
-	| _
-	? 1
-	: 2
-	? Then
-	: Else
+export type IdentityEqual<A, B, Then, Else> = Equal.$Same<A, B, { $then: Then; $else: Else }>

package/src/equal/is_equal.ts

@@ -0,0 +1,150 @@
+import type { IsAny } from '../any/is_any.js'
+import type { And, Or } from '../logical/logical.js'
+import type { IsNever } from '../never/is_never.js'
+import type { IsObject } from '../object/is_object.js'
+import type { Properties } from '../object/properties.js'
+import type { IsSymbol } from '../symbol/is_symbol.js'
+import type { IdentityEqual } from './identity_equal.js'
+
+type BothNever<A, B, Both, One, None> = And<
+	IsNever<A>,
+	IsNever<B>,
+	{
+		$then: Both
+		$else: Or<
+			IsNever<A>,
+			IsNever<B>,
+			{
+				$then: One
+				$else: None
+			}
+		>
+	}
+>
+
+type BothAny<A, B, Both, One, None> = And<
+	IsAny<A>,
+	IsAny<B>,
+	{
+		$then: Both
+		$else: Or<
+			IsAny<A>,
+			IsAny<B>,
+			{
+				$then: One
+				$else: None
+			}
+		>
+	}
+>
+
+/**
+ * Checks `A` and `B` are equal.
+ *
+ * ```ts
+ * type R = IsEqual<1, 1> // true
+ * type R = IsEqual<any, any> // true
+ * type R = IsEqual<boolean, boolean> // true
+ * type R = IsEqual<true, true> // true
+ * type R = IsEqual<[1], [1]> // true
+ *
+ * type R = IsEqual<boolean, true> // false
+ * type R = IsEqual<any, 1> // false
+ * type R = IsEqual<[any], [1]> // false
+ * type R = IsEqual<{ a: 1 }, { a: 1; b: 2 }> // false
+ * ```
+ *
+ * Note that intersection type checks only works at first level.
+ * It cannot be check recursively,
+ * or else will run into infinite recursion if the type includes recursive types.
+ *
+ * @deprecated 💀 **deprecated since 8.0.0**: use `Equal` instead.
+ */
+export type IsEqual<A, B, Then = true, Else = false> = [A, B] extends [B, A]
+	? BothNever<
+			A,
+			B,
+			Then,
+			Else,
+			BothAny<
+				A,
+				B,
+				Then,
+				Else,
+				IdentityEqual<
+					A,
+					B,
+					Then,
+					And<
+						IsObject<A>,
+						IsObject<B>,
+						{
+							$then: IdentityEqual<
+								Properties<A>,
+								Properties<B>,
+								[A, B] extends [(...args: infer P1) => any, (...args: infer P2) => any]
+									? IsEqual<P1, P2, Then, Else>
+									: Then,
+								Else
+							>
+							// `A` and `B` are narrowed, need to check again.
+							// This is fixed in TS 5.0.2, but keeping it to support older versions.
+							$else: [A, B] extends [B, A] ? Then : Else
+						}
+					>
+				>
+			>
+		>
+	: And<
+			IsSymbol<A, { distributive: false }>,
+			IsSymbol<B, { distributive: false }>,
+			{
+				$then: Then
+				$else: Else
+			}
+		>
+
+/**
+ * Checks `A` and `B` are not equal.
+ *
+ * ```ts
+ * type R = IsNotEqual<1, 1> // false
+ * type R = IsNotEqual<any, any> // false
+ * type R = IsNotEqual<boolean, boolean> // false
+ * type R = IsNotEqual<true, true> // false
+ * type R = IsNotEqual<[1], [1]> // false
+ *
+ * type R = IsNotEqual<boolean, true> // true
+ * type R = IsNotEqual<any, 1> // true
+ * type R = IsNotEqual<[any], [1]> // true
+ * type R = IsNotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * ```
+ *
+ * Note that intersection type checks only works at first level.
+ * It cannot be check recursively,
+ * or else will run into infinite recursion if the type includes recursive types.
+ *
+ * @deprecated 💀 **deprecated since 8.0.0**: use `Equal` instead.
+ */
+export type IsNotEqual<A, B, Then = true, Else = false> = IsEqual<A, B, Else, Then>
+
+/**
+ * Checks `A` and `B` are not equal.
+ *
+ * @deprecated this will be changed to `filter` variant in the future.
+ * Please use `IsNotEqual` for the `predicate` behavior.
+ *
+ * ```ts
+ * type R = NotEqual<1, 1> // false
+ * type R = NotEqual<any, any> // false
+ * type R = NotEqual<boolean, boolean> // false
+ * type R = NotEqual<true, true> // false
+ * type R = NotEqual<[1], [1]> // false
+ *
+ * type R = NotEqual<boolean, true> // true
+ * type R = NotEqual<any, 1> // true
+ * type R = NotEqual<[any], [1]> // true
+ * type R = NotEqual<{ a: 1 }, { a: 1; b: 2 }> // true
+ * ```
+ */
+export type NotEqual<A, B, Then = true, Else = false> = IsNotEqual<A, B, Then, Else>

package/src/equal/readme.md

@@ -1,4 +1,23 @@
-# IsEqual
+# Equality
+
+Equality check in TypeScript is hard.
+
+In fact, it is impossible to implement a perfect equality check in TypeScript,
+unless TypeScript itself provides a built-in type for it.
+
+## [`Equal`](./equal.ts)
+
+🏷️ **since 8.0.0**
+
+`Equal<A, B>` checks if `A` and `B` are equal.
+
+Note that intersection type checks only works at first level.
+It cannot be checked recursively,
+or else will run into infinite recursion if the type includes recursive types.
+
+## [`IsEqual`](./is_equal.ts)
+
+💀 **deprecated since 8.0.0**: use [`Equal`] instead.
 
 `IsEqual<A, B>` and friends check if `A` and `B` are equal.
 

package/src/function/is_function.ts

@@ -1,4 +1,15 @@
-import type { $Select } from '../type_plus/branch/$select.js'
+import type { $InputOptions } from '../$type/branch/$input_options.js'
+import type { $ResolveBranch } from '../$type/branch/$resolve_branch.js'
+import type { $Else, $Selection } from '../$type/branch/$selection.js'
+import type { $Distributive } from '../$type/distributive/$distributive.js'
+import type { $Exact } from '../$type/exact/$exact.js'
+import type { $Any } from '../$type/special/$any.js'
+import type { $Never } from '../$type/special/$never.js'
+import type { $Special } from '../$type/special/$special.js'
+import type { $Unknown } from '../$type/special/$unknown.js'
+import type { $Void } from '../$type/special/$void.js'
+import type { $MergeOptions } from '../$type/utils/$merge_options.js'
+import type { Assignable } from '../predicates/assignable.js'
 
 /**
  * 🎭 *predicate*
@@ -53,10 +64,31 @@ import type { $Select } from '../type_plus/branch/$select.js'
  * type R = IsFunction<string, $SelectionBranch> // $Else
  * ```
  */
-export type IsFunction<T, $O extends IsFunction.$Options = {}> = $Select<T, Function, $O>
+export type IsFunction<T, $O extends IsFunction.$Options = {}> = $Special<
+	T,
+	$MergeOptions<
+		$O,
+		{
+			$then: $ResolveBranch<$O, [$Else]>
+			$else: IsFunction.$<T, $O>
+		}
+	>
+>
 
 export namespace IsFunction {
-	export type $Options = $Select.$Options
-	export type $Default = $Select.$Default
-	export type $Branch = $Select.$Branch
+	export type $Options = $Selection.Options &
+		$Distributive.Options &
+		$Exact.Options &
+		$InputOptions<$Any | $Unknown | $Never | $Void>
+	export type $Default = $Selection.Predicate & $Distributive.Default & $Exact.Default
+	export type $Branch<$O extends $Options = {}> = $Selection.Branch<$O>
+	/**
+	 * 🧰 *type util*
+	 *
+	 * Validate if `T` is `Function`.
+	 *
+	 * This is a type util for building custom types.
+	 * It does not check against special types.
+	 */
+	export type $<T, $O extends Assignable.$UtilOptions> = Assignable.$<T, Function, $O>
 }