From 33c02089f5d2f4c0cd02ce29051c0668e50a1446 Mon Sep 17 00:00:00 2001
From: unional <homawong@gmail.com>
Date: Tue, 3 Oct 2023 23:14:02 -0700
Subject: [PATCH] feat: update IsFunction types

---
 .changeset/large-windows-obey.md              |  7 ++
 .../ts/bigint/is_not_strict_bigint.spec.ts    |  5 +-
 type-plus/ts/bigint/is_not_strict_bigint.ts   | 15 ++--
 type-plus/ts/bigint/is_strict_bigint.spec.ts  |  4 +-
 type-plus/ts/bigint/is_strict_bigint.ts       | 18 ++--
 .../ts/boolean/is_not_strict_boolean.spec.ts  |  1 +
 type-plus/ts/boolean/is_not_strict_boolean.ts |  4 +-
 type-plus/ts/boolean/is_strict_boolean.ts     | 12 +--
 .../function_type.is_not_function.spec.ts     | 59 ------------
 .../function_type.not_function_type.spec.ts   | 57 ------------
 type-plus/ts/function/function_type.spec.ts   | 59 ------------
 type-plus/ts/function/function_type.ts        | 67 --------------
 ...s_function.spec.ts => is_function.spec.ts} | 40 ++++++---
 type-plus/ts/function/is_function.ts          | 23 +++++
 type-plus/ts/function/is_not_function.spec.ts | 80 +++++++++++++++++
 type-plus/ts/function/is_not_function.ts      | 22 +++++
 .../function/is_not_strict_function.spec.ts   | 89 +++++++++++++++++++
 .../ts/function/is_not_strict_function.ts     | 40 +++++++++
 .../ts/function/is_strict_function.spec.ts    | 77 ++++++++++++++++
 type-plus/ts/function/is_strict_function.ts   | 40 +++++++++
 ...nction_type.is_not_strict_function.spec.ts | 59 ------------
 ...t_function_type.is_strict_function.spec.ts | 59 ------------
 ...tion_type.not_strict_function_type.spec.ts | 60 -------------
 .../ts/function/strict_function_type.spec.ts  | 60 -------------
 type-plus/ts/function/strict_function_type.ts | 55 ------------
 type-plus/ts/index.ts                         | 11 +--
 type-plus/ts/mix_types/box.ts                 | 50 ++++++-----
 .../select_invert_strict_with_distribute.ts   | 15 +++-
 .../branch/select_strict_with_distribute.ts   | 84 +++++++++++++++++
 29 files changed, 563 insertions(+), 609 deletions(-)
 create mode 100644 .changeset/large-windows-obey.md
 delete mode 100644 type-plus/ts/function/function_type.is_not_function.spec.ts
 delete mode 100644 type-plus/ts/function/function_type.not_function_type.spec.ts
 delete mode 100644 type-plus/ts/function/function_type.spec.ts
 delete mode 100644 type-plus/ts/function/function_type.ts
 rename type-plus/ts/function/{function_type.is_function.spec.ts => is_function.spec.ts} (50%)
 create mode 100644 type-plus/ts/function/is_function.ts
 create mode 100644 type-plus/ts/function/is_not_function.spec.ts
 create mode 100644 type-plus/ts/function/is_not_function.ts
 create mode 100644 type-plus/ts/function/is_not_strict_function.spec.ts
 create mode 100644 type-plus/ts/function/is_not_strict_function.ts
 create mode 100644 type-plus/ts/function/is_strict_function.spec.ts
 create mode 100644 type-plus/ts/function/is_strict_function.ts
 delete mode 100644 type-plus/ts/function/strict_function_type.is_not_strict_function.spec.ts
 delete mode 100644 type-plus/ts/function/strict_function_type.is_strict_function.spec.ts
 delete mode 100644 type-plus/ts/function/strict_function_type.not_strict_function_type.spec.ts
 delete mode 100644 type-plus/ts/function/strict_function_type.spec.ts
 delete mode 100644 type-plus/ts/function/strict_function_type.ts
 create mode 100644 type-plus/ts/type_plus/branch/select_strict_with_distribute.ts

diff --git a/.changeset/large-windows-obey.md b/.changeset/large-windows-obey.md
new file mode 100644
index 0000000000..d1517ed0de
--- /dev/null
+++ b/.changeset/large-windows-obey.md
@@ -0,0 +1,7 @@
+---
+"type-plus": minor
+---
+
+Update `IsFunction`, `IsNotFunction`, `IsStrictFunction`, `IsNotStrictFunction`.
+
+Remove `FunctionType`, `NotFunctionType`, `StrictFunctionType`, `NotStrictFunctionType`.
diff --git a/type-plus/ts/bigint/is_not_strict_bigint.spec.ts b/type-plus/ts/bigint/is_not_strict_bigint.spec.ts
index 5b38050076..e84bb77010 100644
--- a/type-plus/ts/bigint/is_not_strict_bigint.spec.ts
+++ b/type-plus/ts/bigint/is_not_strict_bigint.spec.ts
@@ -43,8 +43,9 @@ it('can disable union distribution', () => {
 	testType.equal<IsNotStrictBigint<bigint | 1, { distributive: false }>, true>(true)
 })
 
-it('consider intersection type as not strict', () => {
-	testType.true<IsNotStrictBigint<bigint & { a: 1 }>>(true)
+it('consider intersection type as strict', () => {
+	testType.false<IsNotStrictBigint<bigint & { a: 1 }>>(true)
+	testType.true<IsNotStrictBigint<1n & { a: 1 }>>(true)
 })
 
 it('works as filter', () => {
diff --git a/type-plus/ts/bigint/is_not_strict_bigint.ts b/type-plus/ts/bigint/is_not_strict_bigint.ts
index f4a04f01ef..882033a25f 100644
--- a/type-plus/ts/bigint/is_not_strict_bigint.ts
+++ b/type-plus/ts/bigint/is_not_strict_bigint.ts
@@ -63,17 +63,16 @@ export type IsNotStrictBigint<
 		: IsNotStrictBigint._N<T, $O>)
 	: never : never
 
-	export namespace IsNotStrictBigint {
+export namespace IsNotStrictBigint {
 	export type $Options = SelectWithDistribute.$Options
 	export type $Default = SelectWithDistribute.$Default
 	export type $Branch = SelectWithDistribute.$Branch
-	export type _D<T, $O extends IsNotStrictBigint.$Options> = (bigint extends T
-		? (T extends bigint
-			? (`${T}` extends `${number}`
-				? $ResolveSelection<$O, T, $Then>
-				: $ResolveSelection<$O, T, $Else>)
-			: $ResolveSelection<$O, T, $Then>)
-		: $ResolveSelection<$O, T, $Then>)
+	export type _D<T, $O extends IsNotStrictBigint.$Options> =
+		T extends bigint
+		? (`${T}` extends `${number}`
+			? $ResolveSelection<$O, T, $Then>
+			: $ResolveSelection<$O, T, $Else>)
+		: $ResolveSelection<$O, T, $Then>
 	export type _N<T, $O extends IsNotStrictBigint.$Options> = ([bigint, T] extends [T, bigint]
 		? (T extends bigint
 			? (`${T}` extends `${number}`
diff --git a/type-plus/ts/bigint/is_strict_bigint.spec.ts b/type-plus/ts/bigint/is_strict_bigint.spec.ts
index 0624d6b375..e7f35fdc13 100644
--- a/type-plus/ts/bigint/is_strict_bigint.spec.ts
+++ b/type-plus/ts/bigint/is_strict_bigint.spec.ts
@@ -43,8 +43,8 @@ it('can disable union distribution', () => {
 	testType.equal<IsStrictBigint<bigint | 1, { distributive: false }>, false>(true)
 })
 
-it('consider intersection type as not strict', () => {
-	testType.false<IsStrictBigint<bigint & { a: 1 }>>(true)
+it('consider intersection type as strict', () => {
+	testType.true<IsStrictBigint<bigint & { a: 1 }>>(true)
 	testType.false<IsStrictBigint<1n & { a: 1 }>>(true)
 })
 
diff --git a/type-plus/ts/bigint/is_strict_bigint.ts b/type-plus/ts/bigint/is_strict_bigint.ts
index 54670acc79..b53f12dce4 100644
--- a/type-plus/ts/bigint/is_strict_bigint.ts
+++ b/type-plus/ts/bigint/is_strict_bigint.ts
@@ -70,14 +70,16 @@ export namespace IsStrictBigint {
 	export type $Options = SelectWithDistribute.$Options
 	export type $Default = SelectWithDistribute.$Default
 	export type $Branch = SelectWithDistribute.$Branch
-	export type _D<T, $O extends IsStrictBigint.$Options> = (bigint extends T
-		? (T extends bigint
-			? (`${T}` extends `${number}`
-				? $ResolveSelection<$O, T, $Else>
-				: $ResolveSelection<$O, T, $Then>)
-			: $ResolveSelection<$O, T, $Else>)
-		: $ResolveSelection<$O, T, $Else>)
-	export type _N<T, $O extends IsStrictBigint.$Options> = ([bigint, T] extends [T, bigint]
+	export type _D<T, $O extends IsStrictBigint.$Options> =
+		T extends bigint
+		? (
+			`${T}` extends `${number}`
+			? $ResolveSelection<$O, T, $Else>
+			: $ResolveSelection<$O, T, $Then>
+		)
+		: $ResolveSelection<$O, T, $Else>
+	export type _N<T, $O extends IsStrictBigint.$Options> = (
+		[bigint, T] extends [T, bigint]
 		? (T extends bigint
 			? (`${T}` extends `${number}`
 				? $ResolveSelection<$O, T, $Else>
diff --git a/type-plus/ts/boolean/is_not_strict_boolean.spec.ts b/type-plus/ts/boolean/is_not_strict_boolean.spec.ts
index 7c4b97aa0d..5d213683e4 100644
--- a/type-plus/ts/boolean/is_not_strict_boolean.spec.ts
+++ b/type-plus/ts/boolean/is_not_strict_boolean.spec.ts
@@ -46,6 +46,7 @@ it('can disable union distribution', () => {
 })
 
 it('returns false for intersection type', () => {
+	// `boolean & { a: 1 }` is considered as strict boolean
 	testType.equal<IsNotStrictBoolean<boolean & { a: 1 }>, false>(true)
 })
 
diff --git a/type-plus/ts/boolean/is_not_strict_boolean.ts b/type-plus/ts/boolean/is_not_strict_boolean.ts
index 1818295d2f..cedfbf0f44 100644
--- a/type-plus/ts/boolean/is_not_strict_boolean.ts
+++ b/type-plus/ts/boolean/is_not_strict_boolean.ts
@@ -18,7 +18,7 @@ import type { IsStrictBoolean } from './is_strict_boolean.js'
  * type R = IsNotStrictBoolean<number> // true
  * type R = IsNotStrictBoolean<unknown> // true
  * type R = IsNotStrictBoolean<string | boolean> // boolean
-  * ```
+	* ```
  *
  * 🔢 *customize*
  *
@@ -71,7 +71,7 @@ export type IsNotStrictBoolean<T, $O extends IsNotStrictBoolean.$Options = {}> =
 			: ['aBcd' | 'Abcd'] extends [R] ? $ResolveSelection<$O, T, $Else> : $ResolveSelection<$O, T, $Then>
 			: never
 		)
-		: [T, boolean] extends [boolean, T] ? $ResolveSelection<$O, T, $Else> : $ResolveSelection<$O, T, $Then>
+		: SelectInvertStrictWithDistribute._N<T, boolean, $O>
 	)
 	: never : never
 
diff --git a/type-plus/ts/boolean/is_strict_boolean.ts b/type-plus/ts/boolean/is_strict_boolean.ts
index 3078f1ef82..0252b5cb30 100644
--- a/type-plus/ts/boolean/is_strict_boolean.ts
+++ b/type-plus/ts/boolean/is_strict_boolean.ts
@@ -1,5 +1,5 @@
 import type { IsAnyOrNever } from '../mix_types/is_any_or_never.js'
-import type { SelectInvertStrictWithDistribute } from '../type_plus/branch/select_invert_strict_with_distribute.js'
+import type { SelectStrictWithDistribute } from '../type_plus/branch/select_strict_with_distribute.js'
 import type { $Else, $ResolveSelection, $SelectionBranch, $Then } from '../type_plus/branch/selection.js'
 import type { $ResolveOptions } from '../type_plus/resolve_options.js'
 
@@ -63,7 +63,7 @@ export type IsStrictBoolean<T, $O extends IsStrictBoolean.$Options = {}> = IsAny
 > extends infer R
 	? R extends $Then ? $ResolveSelection<$O, T, $Else>
 	: R extends $Else ? (
-		$ResolveOptions<[$O['distributive'], SelectInvertStrictWithDistribute.$Default['distributive']]> extends true
+		$ResolveOptions<[$O['distributive'], SelectStrictWithDistribute.$Default['distributive']]> extends true
 		? (
 			IsStrictBoolean._DistributeMap<T> extends infer R
 			? ['aBcD' | 'AbCd' | 'abcd'] extends [R] ? $ResolveSelection<$O, boolean, $Then> | $ResolveSelection<$O, Exclude<T, boolean>, $Else>
@@ -71,14 +71,14 @@ export type IsStrictBoolean<T, $O extends IsStrictBoolean.$Options = {}> = IsAny
 			: ['aBcd' | 'Abcd'] extends [R] ? $ResolveSelection<$O, T, $Then> : $ResolveSelection<$O, T, $Else>
 			: never
 		)
-		: [T, boolean] extends [boolean, T] ? $ResolveSelection<$O, T, $Then> : $ResolveSelection<$O, T, $Else>
+		: SelectStrictWithDistribute._N<T, boolean, $O>
 	)
 	: never : never
 
 export namespace IsStrictBoolean {
-	export type $Options = SelectInvertStrictWithDistribute.$Options
-	export type $Default = SelectInvertStrictWithDistribute.$Default
-	export type $Branch = SelectInvertStrictWithDistribute.$Branch
+	export type $Options = SelectStrictWithDistribute.$Options
+	export type $Default = SelectStrictWithDistribute.$Default
+	export type $Branch = SelectStrictWithDistribute.$Branch
 
 	export type _DistributeMap<T> = T extends true
 		? (T extends false
diff --git a/type-plus/ts/function/function_type.is_not_function.spec.ts b/type-plus/ts/function/function_type.is_not_function.spec.ts
deleted file mode 100644
index 541d308a9b..0000000000
--- a/type-plus/ts/function/function_type.is_not_function.spec.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type IsNotFunction } from '../index.js'
-
-it('returns false if T is Function', () => {
-	testType.false<IsNotFunction<Function>>(true)
-})
-
-it('returns false if T is function signature', () => {
-	testType.false<IsNotFunction<() => void>>(true)
-	testType.false<IsNotFunction<AnyFunction>>(true)
-})
-
-it('returns true for special types', () => {
-	testType.true<IsNotFunction<void>>(true)
-	testType.true<IsNotFunction<unknown>>(true)
-	testType.true<IsNotFunction<any>>(true)
-	testType.true<IsNotFunction<never>>(true)
-})
-
-it('returns true for all other types', () => {
-	testType.true<IsNotFunction<undefined>>(true)
-	testType.true<IsNotFunction<null>>(true)
-	testType.true<IsNotFunction<boolean>>(true)
-	testType.true<IsNotFunction<true>>(true)
-	testType.true<IsNotFunction<false>>(true)
-	testType.true<IsNotFunction<number>>(true)
-	testType.true<IsNotFunction<1>>(true)
-	testType.true<IsNotFunction<string>>(true)
-	testType.true<IsNotFunction<''>>(true)
-	testType.true<IsNotFunction<symbol>>(true)
-	testType.true<IsNotFunction<bigint>>(true)
-	testType.true<IsNotFunction<1n>>(true)
-	testType.true<IsNotFunction<{}>>(true)
-	testType.true<IsNotFunction<{ a: 1 }>>(true)
-	testType.true<IsNotFunction<string[]>>(true)
-	testType.true<IsNotFunction<[]>>(true)
-})
-
-it('returns true if T is union of function and other types', () => {
-	testType.true<IsNotFunction<Function | { a: 1 }>>(true)
-})
-
-it('returns false if T is function overloads', () => {
-	testType.false<IsNotFunction<{ (): void, (x: number): number }>>(true)
-})
-
-it('returns false if T is intersection of function', () => {
-	testType.false<IsNotFunction<Function & { a: 1 }>>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<IsNotFunction<Function, 1, 2>, 2>(true)
-	testType.equal<IsNotFunction<{}, 1, 2>, 1>(true)
-
-	testType.equal<IsNotFunction<any, 1, 2>, 1>(true)
-	testType.equal<IsNotFunction<unknown, 1, 2>, 1>(true)
-	testType.equal<IsNotFunction<never, 1, 2>, 1>(true)
-	testType.equal<IsNotFunction<void, 1, 2>, 1>(true)
-})
diff --git a/type-plus/ts/function/function_type.not_function_type.spec.ts b/type-plus/ts/function/function_type.not_function_type.spec.ts
deleted file mode 100644
index d50b3eeb36..0000000000
--- a/type-plus/ts/function/function_type.not_function_type.spec.ts
+++ /dev/null
@@ -1,57 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type NotFunctionType } from '../index.js'
-
-it('returns never if T is Function', () => {
-	testType.never<NotFunctionType<Function>>(true)
-})
-
-it('returns never if T is function signature', () => {
-	testType.never<NotFunctionType<() => void>>(true)
-	testType.never<NotFunctionType<AnyFunction>>(true)
-})
-
-it('returns T for special types', () => {
-	testType.equal<NotFunctionType<void>, void>(true)
-	testType.equal<NotFunctionType<unknown>, unknown>(true)
-	testType.equal<NotFunctionType<any>, any>(true)
-	testType.equal<NotFunctionType<never>, never>(true)
-})
-
-it('returns T for all other types', () => {
-	testType.equal<NotFunctionType<undefined>, undefined>(true)
-	testType.equal<NotFunctionType<null>, null>(true)
-	testType.equal<NotFunctionType<boolean>, boolean>(true)
-	testType.equal<NotFunctionType<true>, true>(true)
-	testType.equal<NotFunctionType<false>, false>(true)
-	testType.equal<NotFunctionType<number>, number>(true)
-	testType.equal<NotFunctionType<1>, 1>(true)
-	testType.equal<NotFunctionType<string>, string>(true)
-	testType.equal<NotFunctionType<''>, ''>(true)
-	testType.equal<NotFunctionType<symbol>, symbol>(true)
-	testType.equal<NotFunctionType<bigint>, bigint>(true)
-	testType.equal<NotFunctionType<{}>, {}>(true)
-	testType.equal<NotFunctionType<string[]>, string[]>(true)
-	testType.equal<NotFunctionType<[]>, []>(true)
-})
-
-it('returns T if T is union of function and other types', () => {
-	testType.equal<NotFunctionType<Function | { a: 1 }>, Function | { a: 1 }>(true)
-})
-
-it('returns never if T is function overloads', () => {
-	testType.never<NotFunctionType<{ (): void, (x: number): number }>>(true)
-})
-
-it('returns never if T is intersection of function', () => {
-	testType.never<NotFunctionType<Function & { a: 1 }>>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<NotFunctionType<Function, 1, 2>, 2>(true)
-	testType.equal<NotFunctionType<{}, 1, 2>, 1>(true)
-
-	testType.equal<NotFunctionType<any, 1, 2>, 1>(true)
-	testType.equal<NotFunctionType<unknown, 1, 2>, 1>(true)
-	testType.equal<NotFunctionType<never, 1, 2>, 1>(true)
-	testType.equal<NotFunctionType<void, 1, 2>, 1>(true)
-})
diff --git a/type-plus/ts/function/function_type.spec.ts b/type-plus/ts/function/function_type.spec.ts
deleted file mode 100644
index 8d8c21b81b..0000000000
--- a/type-plus/ts/function/function_type.spec.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type FunctionType } from '../index.js'
-
-it('returns T if T is Function', () => {
-	testType.equal<FunctionType<Function>, Function>(true)
-})
-
-it('returns T if T is a function signature', () => {
-	testType.equal<FunctionType<() => void>, () => void>(true)
-	testType.equal<FunctionType<AnyFunction>, AnyFunction>(true)
-})
-
-it('returns never for special types', () => {
-	testType.never<FunctionType<void>>(true)
-	testType.never<FunctionType<unknown>>(true)
-	testType.never<FunctionType<any>>(true)
-	testType.never<FunctionType<never>>(true)
-})
-
-it('returns never for other types', () => {
-	testType.never<FunctionType<undefined>>(true)
-	testType.never<FunctionType<null>>(true)
-	testType.never<FunctionType<boolean>>(true)
-	testType.never<FunctionType<true>>(true)
-	testType.never<FunctionType<false>>(true)
-	testType.never<FunctionType<number>>(true)
-	testType.never<FunctionType<1>>(true)
-	testType.never<FunctionType<string>>(true)
-	testType.never<FunctionType<''>>(true)
-	testType.never<FunctionType<symbol>>(true)
-	testType.never<FunctionType<bigint>>(true)
-	testType.never<FunctionType<{}>>(true)
-	testType.never<FunctionType<string[]>>(true)
-	testType.never<FunctionType<[]>>(true)
-})
-
-it('returns never if T is union of function and other types', () => {
-	testType.never<FunctionType<Function | { a: 1 }>>(true)
-})
-
-it('returns T if T is function overloads', () => {
-	testType.equal<FunctionType<{ (): void, (x: number): number }>, { (): void, (x: number): number }>(true)
-	testType.equal<FunctionType<{ (): void, a: 1 }>, { (): void, a: 1 }>(true)
-})
-
-it('returns T if T is intersection of function', () => {
-	testType.equal<FunctionType<Function & { a: 1 }>, Function & { a: 1 }>(true)
-	testType.equal<FunctionType<Function & 1>, Function & 1>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<FunctionType<Function, 1, 2>, 1>(true)
-	testType.equal<FunctionType<0, 1, 2>, 2>(true)
-
-	testType.equal<FunctionType<any, 1, 2>, 2>(true)
-	testType.equal<FunctionType<unknown, 1, 2>, 2>(true)
-	testType.equal<FunctionType<never, 1, 2>, 2>(true)
-	testType.equal<FunctionType<void, 1, 2>, 2>(true)
-})
diff --git a/type-plus/ts/function/function_type.ts b/type-plus/ts/function/function_type.ts
deleted file mode 100644
index 8fc8950e9e..0000000000
--- a/type-plus/ts/function/function_type.ts
+++ /dev/null
@@ -1,67 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/is_any_or_never.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/selection.js'
-
-/**
- * Check if `T` is a `Function`.
- *
- * ```ts
- * type R = FunctionType<Function> // Function
- * type R = FunctionType<() => void> // () => void
- * type R = FunctionType<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
- *
- * type R = FunctionType<{ a: 1 }> // never
- * type R = FunctionType<never> // never
- * type R = FunctionType<unknown> // never
- * ```
- */
-export type FunctionType<T, Then = T, Else = never> = IsAnyOrNever<
-	T,
-	$SelectionBranch
-> extends infer R
-	? R extends $Then ? Else
-	: R extends $Else ? [T] extends [Function] ? Then : Else
-	: never : never
-
-/**
- * Is `T` a `Function`.
- *
- * ```ts
- * type R = IsFunction<Function> // Function
- * type R = IsFunction<() => void> // () => void
- * type R = IsFunction<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
- *
- * type R = IsFunction<{ a: 1 }> // never
- * type R = IsFunction<never> // never
- * type R = IsFunction<unknown> // never
- * ```
- */
-export type IsFunction<T, Then = true, Else = false> = FunctionType<T, Then, Else>
-
-/**
- * Check if `T` is not a `Function`.
- *
- * ```ts
- * type R = NotFunctionType<Function> // never
- * type R = NotFunctionType<() => void> // never
- * type R = NotFunctionType<(() => void) | { a: 1 }> // never
- *
- * type R = NotFunctionType<{ a: 1 }> // { a: 1 }
- * type R = NotFunctionType<never> // never
- * type R = NotFunctionType<unknown> // unknown
- * ```
- */
-export type NotFunctionType<T, Then = T, Else = never> = FunctionType<T, Else, Then>
-
-/**
- * Is `T` not a `Function`.
- *
- * ```ts
- * type R = IsNotFunction<Function> // false
- * type R = IsNotFunction<() => void> // false
- * type R = IsNotFunction<(() => void) | { a: 1 }> // false
- *
- * type R = IsNotFunction<{ a: 1 }> // true
- * type R = IsNotFunction<never> // true
- * ```
- */
-export type IsNotFunction<T, Then = true, Else = false> = FunctionType<T, Else, Then>
diff --git a/type-plus/ts/function/function_type.is_function.spec.ts b/type-plus/ts/function/is_function.spec.ts
similarity index 50%
rename from type-plus/ts/function/function_type.is_function.spec.ts
rename to type-plus/ts/function/is_function.spec.ts
index f5f93aa90e..393adc24e2 100644
--- a/type-plus/ts/function/function_type.is_function.spec.ts
+++ b/type-plus/ts/function/is_function.spec.ts
@@ -1,5 +1,5 @@
 import { it } from '@jest/globals'
-import { testType, type AnyFunction, type IsFunction } from '../index.js'
+import { testType, type AnyFunction, type IsFunction, type $Then, type $Else } from '../index.js'
 
 it('returns true if T is Function', () => {
 	testType.true<IsFunction<Function>>(true)
@@ -11,9 +11,9 @@ it('returns true if T is function signature', () => {
 })
 
 it('returns false for special types', () => {
-	testType.false<IsFunction<void>>(true)
-	testType.false<IsFunction<unknown>>(true)
 	testType.false<IsFunction<any>>(true)
+	testType.false<IsFunction<unknown>>(true)
+	testType.false<IsFunction<void>>(true)
 	testType.false<IsFunction<never>>(true)
 })
 
@@ -36,8 +36,25 @@ it('returns false for all other types', () => {
 	testType.false<IsFunction<[]>>(true)
 })
 
-it('returns false if T is union of function', () => {
-	testType.false<IsFunction<Function | { a: 1 }>>(true)
+it('works as filter', () => {
+	testType.equal<IsFunction<Function, { selection: 'filter' }>, Function>(true)
+	testType.equal<IsFunction<() => void, { selection: 'filter' }>, () => void>(true)
+
+	testType.equal<IsFunction<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsFunction<unknown, { selection: 'filter' }>, never>(true)
+	testType.equal<IsFunction<string | boolean, { selection: 'filter' }>, never>(true)
+
+	testType.equal<IsFunction<string | Function, { selection: 'filter' }>, Function>(true)
+	testType.equal<IsFunction<string | (() => string), { selection: 'filter' }>, () => string>(true)
+})
+
+it('distributes over union type', () => {
+	testType.equal<Function | 1, Function | 1>(true)
+	testType.equal<IsFunction<Function | 1>, boolean>(true)
+})
+
+it('can disable union distribution', () => {
+	testType.false<IsFunction<Function | 1, { distributive: false }>>(true)
 })
 
 it('returns true if T is function overloads', () => {
@@ -48,11 +65,12 @@ it('returns true if T is intersection of function', () => {
 	testType.true<IsFunction<Function & { a: 1 }>>(true)
 })
 
-it('can override Then/Else', () => {
-	testType.equal<IsFunction<Function, 1, 2>, 1>(true)
+it('works with unique branches', () => {
+	testType.equal<IsFunction<Function, IsFunction.$Branch>, $Then>(true)
+	testType.equal<IsFunction<() => boolean, IsFunction.$Branch>, $Then>(true)
 
-	testType.equal<IsFunction<any, 1, 2>, 2>(true)
-	testType.equal<IsFunction<unknown, 1, 2>, 2>(true)
-	testType.equal<IsFunction<never, 1, 2>, 2>(true)
-	testType.equal<IsFunction<void, 1, 2>, 2>(true)
+	testType.equal<IsFunction<any, IsFunction.$Branch>, $Else>(true)
+	testType.equal<IsFunction<unknown, IsFunction.$Branch>, $Else>(true)
+	testType.equal<IsFunction<never, IsFunction.$Branch>, $Else>(true)
+	testType.equal<IsFunction<void, IsFunction.$Branch>, $Else>(true)
 })
diff --git a/type-plus/ts/function/is_function.ts b/type-plus/ts/function/is_function.ts
new file mode 100644
index 0000000000..f4abc624e1
--- /dev/null
+++ b/type-plus/ts/function/is_function.ts
@@ -0,0 +1,23 @@
+import type { SelectWithDistribute } from '../type_plus/branch/select_with_distribute.js'
+
+/**
+ * Is `T` a `Function`.
+ *
+ * ```ts
+ * type R = IsFunction<Function> // Function
+ * type R = IsFunction<() => void> // () => void
+ * type R = IsFunction<(() => void) | { a: 1 }> // (() => void) | { a: 1 }
+ *
+ * type R = IsFunction<{ a: 1 }> // never
+ * type R = IsFunction<never> // never
+ * type R = IsFunction<unknown> // never
+ * ```
+ */
+
+export type IsFunction<T, $O extends IsFunction.$Options = {}> = SelectWithDistribute<T, Function, $O>
+
+export namespace IsFunction {
+	export type $Options = SelectWithDistribute.$Options
+	export type $Default = SelectWithDistribute.$Default
+	export type $Branch = SelectWithDistribute.$Branch
+}
diff --git a/type-plus/ts/function/is_not_function.spec.ts b/type-plus/ts/function/is_not_function.spec.ts
new file mode 100644
index 0000000000..bc775044d8
--- /dev/null
+++ b/type-plus/ts/function/is_not_function.spec.ts
@@ -0,0 +1,80 @@
+import { it } from '@jest/globals'
+import { testType, type AnyFunction, type IsNotFunction, type $Else, type $Then } from '../index.js'
+
+it('returns false if T is Function', () => {
+	testType.false<IsNotFunction<Function>>(true)
+})
+
+it('returns false if T is function signature', () => {
+	testType.false<IsNotFunction<() => void>>(true)
+	testType.false<IsNotFunction<AnyFunction>>(true)
+})
+
+it('returns true for special types', () => {
+	testType.true<IsNotFunction<void>>(true)
+	testType.true<IsNotFunction<unknown>>(true)
+	testType.true<IsNotFunction<any>>(true)
+	testType.true<IsNotFunction<never>>(true)
+})
+
+it('returns true for all other types', () => {
+	testType.true<IsNotFunction<undefined>>(true)
+	testType.true<IsNotFunction<null>>(true)
+	testType.true<IsNotFunction<boolean>>(true)
+	testType.true<IsNotFunction<true>>(true)
+	testType.true<IsNotFunction<false>>(true)
+	testType.true<IsNotFunction<number>>(true)
+	testType.true<IsNotFunction<1>>(true)
+	testType.true<IsNotFunction<string>>(true)
+	testType.true<IsNotFunction<''>>(true)
+	testType.true<IsNotFunction<symbol>>(true)
+	testType.true<IsNotFunction<bigint>>(true)
+	testType.true<IsNotFunction<1n>>(true)
+	testType.true<IsNotFunction<{}>>(true)
+	testType.true<IsNotFunction<{ a: 1 }>>(true)
+	testType.true<IsNotFunction<string[]>>(true)
+	testType.true<IsNotFunction<[]>>(true)
+})
+
+it('distributes over union type', () => {
+	testType.equal<IsNotFunction<Function | string>, boolean>(true)
+	testType.equal<IsNotFunction<(() => void) | string>, boolean>(true)
+})
+
+
+it('returns false if T is function overloads', () => {
+	testType.false<IsNotFunction<{ (): void, (x: number): number }>>(true)
+})
+
+it('returns false if T is intersection of function', () => {
+	testType.false<IsNotFunction<Function & { a: 1 }>>(true)
+})
+
+it('can disable union distribution', () => {
+	testType.equal<IsNotFunction<Function | 1>, boolean>(true)
+	testType.equal<IsNotFunction<Function | 1, { distributive: false }>, true>(true)
+	testType.true<IsNotFunction<Function | string, { distributive: false }>>(true)
+})
+
+it('works as filter', () => {
+	testType.equal<IsNotFunction<Function, { selection: 'filter' }>, never>(true)
+	testType.equal<IsNotFunction<() => boolean, { selection: 'filter' }>, never>(true)
+
+	testType.equal<IsNotFunction<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsNotFunction<unknown, { selection: 'filter' }>, unknown>(true)
+	testType.equal<IsNotFunction<Function | boolean, { selection: 'filter' }>, boolean>(true)
+
+	testType.equal<IsNotFunction<Function | 1, { selection: 'filter' }>, 1>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsNotFunction<Function, IsNotFunction.$Branch>, $Else>(true)
+	testType.equal<IsNotFunction<() => void, IsNotFunction.$Branch>, $Else>(true)
+
+	testType.equal<IsNotFunction<any, IsNotFunction.$Branch>, $Then>(true)
+	testType.equal<IsNotFunction<unknown, IsNotFunction.$Branch>, $Then>(true)
+	testType.equal<IsNotFunction<never, IsNotFunction.$Branch>, $Then>(true)
+	testType.equal<IsNotFunction<void, IsNotFunction.$Branch>, $Then>(true)
+
+	testType.equal<IsNotFunction<Function | 1, IsNotFunction.$Branch>, $Then | $Else>(true)
+})
diff --git a/type-plus/ts/function/is_not_function.ts b/type-plus/ts/function/is_not_function.ts
new file mode 100644
index 0000000000..50e1237da7
--- /dev/null
+++ b/type-plus/ts/function/is_not_function.ts
@@ -0,0 +1,22 @@
+import type { SelectInvertWithDistribute } from '../type_plus/branch/select_invert_with_distribute.js'
+
+/**
+ * Is `T` not a `Function`.
+ *
+ * ```ts
+ * type R = IsNotFunction<Function> // false
+ * type R = IsNotFunction<() => void> // false
+ * type R = IsNotFunction<(() => void) | { a: 1 }> // false
+ *
+ * type R = IsNotFunction<{ a: 1 }> // true
+ * type R = IsNotFunction<never> // true
+ * ```
+ */
+
+export type IsNotFunction<T, $O extends IsNotFunction.$Options = {}> = SelectInvertWithDistribute<T, Function, $O>
+
+export namespace IsNotFunction {
+	export type $Options = SelectInvertWithDistribute.$Options
+	export type $Default = SelectInvertWithDistribute.$Default
+	export type $Branch = SelectInvertWithDistribute.$Branch
+}
diff --git a/type-plus/ts/function/is_not_strict_function.spec.ts b/type-plus/ts/function/is_not_strict_function.spec.ts
new file mode 100644
index 0000000000..4a0c2b1409
--- /dev/null
+++ b/type-plus/ts/function/is_not_strict_function.spec.ts
@@ -0,0 +1,89 @@
+import { it } from '@jest/globals'
+import { testType, type $Else, type $Then, type AnyFunction, type IsNotStrictFunction } from '../index.js'
+
+it('returns false if T is Function', () => {
+	testType.false<IsNotStrictFunction<Function>>(true)
+})
+
+it('returns true if T is function signature', () => {
+	testType.true<IsNotStrictFunction<() => void>>(true)
+	testType.true<IsNotStrictFunction<AnyFunction>>(true)
+})
+
+it('returns true for special types', () => {
+	testType.true<IsNotStrictFunction<void>>(true)
+	testType.true<IsNotStrictFunction<unknown>>(true)
+	testType.true<IsNotStrictFunction<any>>(true)
+	testType.true<IsNotStrictFunction<never>>(true)
+})
+
+it('returns true for all other types', () => {
+	testType.true<IsNotStrictFunction<undefined>>(true)
+	testType.true<IsNotStrictFunction<null>>(true)
+	testType.true<IsNotStrictFunction<boolean>>(true)
+	testType.true<IsNotStrictFunction<true>>(true)
+	testType.true<IsNotStrictFunction<false>>(true)
+	testType.true<IsNotStrictFunction<number>>(true)
+	testType.true<IsNotStrictFunction<1>>(true)
+	testType.true<IsNotStrictFunction<string>>(true)
+	testType.true<IsNotStrictFunction<''>>(true)
+	testType.true<IsNotStrictFunction<symbol>>(true)
+	testType.true<IsNotStrictFunction<bigint>>(true)
+	testType.true<IsNotStrictFunction<1n>>(true)
+	testType.true<IsNotStrictFunction<{}>>(true)
+	testType.true<IsNotStrictFunction<{ a: 1 }>>(true)
+	testType.true<IsNotStrictFunction<string[]>>(true)
+	testType.true<IsNotStrictFunction<[]>>(true)
+})
+
+it('distributes over union type', () => {
+	testType.equal<Function | { a: 1 }, Function | { a: 1 }>(true)
+	// `false | true` -> `boolean`
+	testType.equal<IsNotStrictFunction<Function | { a: 1 }>, boolean>(true)
+	// `true | true` -> `true`
+	testType.equal<IsNotStrictFunction<(() => void) | { a: 1 }>, true>(true)
+})
+
+it('can disable union distribution', () => {
+	testType.equal<IsNotStrictFunction<Function | string, { distributive: false }>, true>(true)
+})
+
+it('returns true if T is function overloads', () => {
+	testType.true<IsNotStrictFunction<{ (): void }>>(true)
+	testType.true<IsNotStrictFunction<{ (): void, (x: number): number }>>(true)
+})
+
+it('returns true if T is function overloads', () => {
+	testType.true<IsNotStrictFunction<{ (): void, (x: number): number }>>(true)
+})
+
+it('returns false if T is intersection of function', () => {
+	testType.false<IsNotStrictFunction<Function & { a: 1 }>>(true)
+})
+
+it('returns true for intersection type', () => {
+	// `Function & { a: 1 }` is considered as strict Function
+	testType.equal<IsNotStrictFunction<Function & { a: 1 }>, false>(true)
+})
+
+it('works as filter', () => {
+	testType.equal<IsNotStrictFunction<Function, { selection: 'filter' }>, never>(true)
+	testType.equal<IsNotStrictFunction<() => void, { selection: 'filter' }>, () => void>(true)
+
+	testType.equal<IsNotStrictFunction<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsNotStrictFunction<unknown, { selection: 'filter' }>, unknown>(true)
+	testType.equal<IsNotStrictFunction<Function | number, { selection: 'filter' }>, number>(true)
+	testType.equal<IsNotStrictFunction<Function | number, { selection: 'filter', distributive: false }>, Function | number>(true)
+
+	testType.equal<IsNotStrictFunction<Function | true, { selection: 'filter' }>, true>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsNotStrictFunction<Function, IsNotStrictFunction.$Branch>, $Else>(true)
+	testType.equal<IsNotStrictFunction<() => void, IsNotStrictFunction.$Branch>, $Then>(true)
+
+	testType.equal<IsNotStrictFunction<any, IsNotStrictFunction.$Branch>, $Then>(true)
+	testType.equal<IsNotStrictFunction<unknown, IsNotStrictFunction.$Branch>, $Then>(true)
+	testType.equal<IsNotStrictFunction<never, IsNotStrictFunction.$Branch>, $Then>(true)
+	testType.equal<IsNotStrictFunction<void, IsNotStrictFunction.$Branch>, $Then>(true)
+})
diff --git a/type-plus/ts/function/is_not_strict_function.ts b/type-plus/ts/function/is_not_strict_function.ts
new file mode 100644
index 0000000000..fe72aaf0de
--- /dev/null
+++ b/type-plus/ts/function/is_not_strict_function.ts
@@ -0,0 +1,40 @@
+import type { IsAnyOrNever } from '../mix_types/is_any_or_never.js'
+import type { SelectInvertStrictWithDistribute } from '../type_plus/branch/select_invert_strict_with_distribute.js'
+import type { $Else, $ResolveSelection, $SelectionBranch, $Then } from '../type_plus/branch/selection.js'
+import type { $ResolveOptions } from '../type_plus/resolve_options.js'
+
+/**
+ * Is `T` not exactly `Function`.
+ *
+ * ```ts
+ * type R = IsNotStrictFunction<Function> // false
+ *
+ * type R = IsNotStrictFunction<() => void> // true
+ * type R = IsNotStrictFunction<(() => void) & { a: 1 }> // true
+ * ```
+ */
+
+export type IsNotStrictFunction<T, $O extends IsNotStrictFunction.$Options = {}> =
+	IsAnyOrNever<
+		T,
+		$SelectionBranch
+	> extends infer R
+	? R extends $Then ? $ResolveSelection<$O, T, $Then>
+	: R extends $Else ? (
+		$ResolveOptions<[$O['distributive'], SelectInvertStrictWithDistribute.$Default['distributive']]> extends true
+		? IsNotStrictFunction._D<T, $O>
+		: SelectInvertStrictWithDistribute._N<T, Function, $O>
+	)
+	: never : never
+
+export namespace IsNotStrictFunction {
+	export type $Options = SelectInvertStrictWithDistribute.$Options
+	export type $Default = SelectInvertStrictWithDistribute.$Default
+	export type $Branch = SelectInvertStrictWithDistribute.$Branch
+	export type _D<T, $O extends IsNotStrictFunction.$Options> =
+		T extends Function
+		? T extends (...args: any[]) => any
+		? $ResolveSelection<$O, T, $Then>
+		: $ResolveSelection<$O, T, $Else>
+		: $ResolveSelection<$O, T, $Then>
+}
diff --git a/type-plus/ts/function/is_strict_function.spec.ts b/type-plus/ts/function/is_strict_function.spec.ts
new file mode 100644
index 0000000000..a787386096
--- /dev/null
+++ b/type-plus/ts/function/is_strict_function.spec.ts
@@ -0,0 +1,77 @@
+import { it } from '@jest/globals'
+import { testType, type AnyFunction, type IsStrictFunction, type $Then, type $Else } from '../index.js'
+
+it('returns true if T is Function', () => {
+	testType.true<IsStrictFunction<Function>>(true)
+})
+
+it('returns false if T is function signature', () => {
+	testType.false<IsStrictFunction<() => void>>(true)
+	testType.false<IsStrictFunction<AnyFunction>>(true)
+})
+
+it('returns false for special types', () => {
+	testType.false<IsStrictFunction<void>>(true)
+	testType.false<IsStrictFunction<unknown>>(true)
+	testType.false<IsStrictFunction<any>>(true)
+	testType.false<IsStrictFunction<never>>(true)
+})
+
+it('returns false for all other types', () => {
+	testType.false<IsStrictFunction<undefined>>(true)
+	testType.false<IsStrictFunction<null>>(true)
+	testType.false<IsStrictFunction<boolean>>(true)
+	testType.false<IsStrictFunction<true>>(true)
+	testType.false<IsStrictFunction<false>>(true)
+	testType.false<IsStrictFunction<number>>(true)
+	testType.false<IsStrictFunction<1>>(true)
+	testType.false<IsStrictFunction<string>>(true)
+	testType.false<IsStrictFunction<''>>(true)
+	testType.false<IsStrictFunction<symbol>>(true)
+	testType.false<IsStrictFunction<bigint>>(true)
+	testType.false<IsStrictFunction<1n>>(true)
+	testType.false<IsStrictFunction<{}>>(true)
+	testType.false<IsStrictFunction<{ a: 1 }>>(true)
+	testType.false<IsStrictFunction<string[]>>(true)
+	testType.false<IsStrictFunction<[]>>(true)
+})
+
+it('distributes over union type', () => {
+	testType.equal<Function | { a: 1 }, Function | { a: 1 }>(true)
+	testType.equal<IsStrictFunction<Function | { a: 1 }>, boolean>(true)
+	testType.equal<IsStrictFunction<(() => void) | { a: 1 }>, false>(true)
+})
+
+it('returns false if T is function overloads', () => {
+	testType.false<IsStrictFunction<{ (): void, (x: number): number }>>(true)
+})
+
+it('can disable union distribution', () => {
+	testType.equal<IsStrictFunction<Function | string, { distributive: false }>, false>(true)
+})
+
+it('returns true for intersection type', () => {
+	testType.equal<IsStrictFunction<Function & { a: 1 }>, true>(true)
+})
+
+it('works as filter', () => {
+	testType.equal<IsStrictFunction<Function, { selection: 'filter' }>, Function>(true)
+	testType.equal<IsStrictFunction<() => void, { selection: 'filter' }>, never>(true)
+
+	testType.equal<IsStrictFunction<never, { selection: 'filter' }>, never>(true)
+	testType.equal<IsStrictFunction<unknown, { selection: 'filter' }>, never>(true)
+	testType.equal<IsStrictFunction<Function | number, { selection: 'filter' }>, Function>(true)
+	testType.equal<IsStrictFunction<Function | number, { selection: 'filter', distributive: false }>, never>(true)
+
+	testType.equal<IsStrictFunction<Function | true, { selection: 'filter' }>, Function>(true)
+})
+
+it('works with unique branches', () => {
+	testType.equal<IsStrictFunction<Function, IsStrictFunction.$Branch>, $Then>(true)
+	testType.equal<IsStrictFunction<() => void, IsStrictFunction.$Branch>, $Else>(true)
+
+	testType.equal<IsStrictFunction<any, IsStrictFunction.$Branch>, $Else>(true)
+	testType.equal<IsStrictFunction<unknown, IsStrictFunction.$Branch>, $Else>(true)
+	testType.equal<IsStrictFunction<never, IsStrictFunction.$Branch>, $Else>(true)
+	testType.equal<IsStrictFunction<void, IsStrictFunction.$Branch>, $Else>(true)
+})
diff --git a/type-plus/ts/function/is_strict_function.ts b/type-plus/ts/function/is_strict_function.ts
new file mode 100644
index 0000000000..636fee43f9
--- /dev/null
+++ b/type-plus/ts/function/is_strict_function.ts
@@ -0,0 +1,40 @@
+import type { IsAnyOrNever } from '../mix_types/is_any_or_never.js'
+import type { SelectStrictWithDistribute } from '../type_plus/branch/select_strict_with_distribute.js'
+import type { $Else, $ResolveSelection, $SelectionBranch, $Then } from '../type_plus/branch/selection.js'
+import type { $ResolveOptions } from '../type_plus/resolve_options.js'
+
+/**
+ * Is `T` exactly `Function`.
+ *
+ * ```ts
+ * type R = IsStrictFunction<Function> // true
+ *
+ * type R = IsStrictFunction<() => void> // false
+ * type R = IsStrictFunction<(() => void) & { a: 1 }> // false
+ * ```
+ */
+
+export type IsStrictFunction<T, $O extends IsStrictFunction.$Options = {}> =
+	IsAnyOrNever<
+		T,
+		$SelectionBranch
+	> extends infer R
+	? R extends $Then ? $ResolveSelection<$O, T, $Else>
+	: R extends $Else ? (
+		$ResolveOptions<[$O['distributive'], SelectStrictWithDistribute.$Default['distributive']]> extends true
+		? IsStrictFunction._D<T, $O>
+		: SelectStrictWithDistribute._N<T, Function, $O>
+	)
+	: never : never
+
+export namespace IsStrictFunction {
+	export type $Options = SelectStrictWithDistribute.$Options
+	export type $Default = SelectStrictWithDistribute.$Default
+	export type $Branch = SelectStrictWithDistribute.$Branch
+	export type _D<T, $O extends SelectStrictWithDistribute.$Options> =
+		T extends Function
+		? T extends (...args: any[]) => any
+		? $ResolveSelection<$O, T, $Else>
+		: $ResolveSelection<$O, T, $Then>
+		: $ResolveSelection<$O, T, $Else>
+}
diff --git a/type-plus/ts/function/strict_function_type.is_not_strict_function.spec.ts b/type-plus/ts/function/strict_function_type.is_not_strict_function.spec.ts
deleted file mode 100644
index df8362bc6e..0000000000
--- a/type-plus/ts/function/strict_function_type.is_not_strict_function.spec.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type IsNotStrictFunction } from '../index.js'
-
-it('returns false if T is Function', () => {
-	testType.false<IsNotStrictFunction<Function>>(true)
-})
-
-it('returns true if T is function signature', () => {
-	testType.true<IsNotStrictFunction<() => void>>(true)
-	testType.true<IsNotStrictFunction<AnyFunction>>(true)
-})
-
-it('returns true for special types', () => {
-	testType.true<IsNotStrictFunction<void>>(true)
-	testType.true<IsNotStrictFunction<unknown>>(true)
-	testType.true<IsNotStrictFunction<any>>(true)
-	testType.true<IsNotStrictFunction<never>>(true)
-})
-
-it('returns true for all other types', () => {
-	testType.true<IsNotStrictFunction<undefined>>(true)
-	testType.true<IsNotStrictFunction<null>>(true)
-	testType.true<IsNotStrictFunction<boolean>>(true)
-	testType.true<IsNotStrictFunction<true>>(true)
-	testType.true<IsNotStrictFunction<false>>(true)
-	testType.true<IsNotStrictFunction<number>>(true)
-	testType.true<IsNotStrictFunction<1>>(true)
-	testType.true<IsNotStrictFunction<string>>(true)
-	testType.true<IsNotStrictFunction<''>>(true)
-	testType.true<IsNotStrictFunction<symbol>>(true)
-	testType.true<IsNotStrictFunction<bigint>>(true)
-	testType.true<IsNotStrictFunction<1n>>(true)
-	testType.true<IsNotStrictFunction<{}>>(true)
-	testType.true<IsNotStrictFunction<{ a: 1 }>>(true)
-	testType.true<IsNotStrictFunction<string[]>>(true)
-	testType.true<IsNotStrictFunction<[]>>(true)
-})
-
-it('returns true if T is union of function and other types', () => {
-	testType.true<IsNotStrictFunction<Function | { a: 1 }>>(true)
-})
-
-it('returns true if T is function overloads', () => {
-	testType.true<IsNotStrictFunction<{ (): void, (x: number): number }>>(true)
-})
-
-it('returns true if T is intersection of function', () => {
-	testType.true<IsNotStrictFunction<Function & { a: 1 }>>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<IsNotStrictFunction<Function, 1, 2>, 2>(true)
-	testType.equal<IsNotStrictFunction<{}, 1, 2>, 1>(true)
-
-	testType.equal<IsNotStrictFunction<any, 1, 2>, 1>(true)
-	testType.equal<IsNotStrictFunction<unknown, 1, 2>, 1>(true)
-	testType.equal<IsNotStrictFunction<never, 1, 2>, 1>(true)
-	testType.equal<IsNotStrictFunction<void, 1, 2>, 1>(true)
-})
diff --git a/type-plus/ts/function/strict_function_type.is_strict_function.spec.ts b/type-plus/ts/function/strict_function_type.is_strict_function.spec.ts
deleted file mode 100644
index 84d4299913..0000000000
--- a/type-plus/ts/function/strict_function_type.is_strict_function.spec.ts
+++ /dev/null
@@ -1,59 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type IsStrictFunction } from '../index.js'
-
-it('returns true if T is Function', () => {
-	testType.true<IsStrictFunction<Function>>(true)
-})
-
-it('returns false if T is function signature', () => {
-	testType.false<IsStrictFunction<() => void>>(true)
-	testType.false<IsStrictFunction<AnyFunction>>(true)
-})
-
-it('returns false for special types', () => {
-	testType.false<IsStrictFunction<void>>(true)
-	testType.false<IsStrictFunction<unknown>>(true)
-	testType.false<IsStrictFunction<any>>(true)
-	testType.false<IsStrictFunction<never>>(true)
-})
-
-it('returns false for all other types', () => {
-	testType.false<IsStrictFunction<undefined>>(true)
-	testType.false<IsStrictFunction<null>>(true)
-	testType.false<IsStrictFunction<boolean>>(true)
-	testType.false<IsStrictFunction<true>>(true)
-	testType.false<IsStrictFunction<false>>(true)
-	testType.false<IsStrictFunction<number>>(true)
-	testType.false<IsStrictFunction<1>>(true)
-	testType.false<IsStrictFunction<string>>(true)
-	testType.false<IsStrictFunction<''>>(true)
-	testType.false<IsStrictFunction<symbol>>(true)
-	testType.false<IsStrictFunction<bigint>>(true)
-	testType.false<IsStrictFunction<1n>>(true)
-	testType.false<IsStrictFunction<{}>>(true)
-	testType.false<IsStrictFunction<{ a: 1 }>>(true)
-	testType.false<IsStrictFunction<string[]>>(true)
-	testType.false<IsStrictFunction<[]>>(true)
-})
-
-it('returns false if T is union of function', () => {
-	testType.false<IsStrictFunction<Function | { a: 1 }>>(true)
-})
-
-it('returns false if T is function overloads', () => {
-	testType.false<IsStrictFunction<{ (): void, (x: number): number }>>(true)
-})
-
-it('returns false if T is intersection of function', () => {
-	testType.false<IsStrictFunction<Function & { a: 1 }>>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<IsStrictFunction<Function, 1, 2>, 1>(true)
-	testType.equal<IsStrictFunction<0, 1, 2>, 2>(true)
-
-	testType.equal<IsStrictFunction<any, 1, 2>, 2>(true)
-	testType.equal<IsStrictFunction<unknown, 1, 2>, 2>(true)
-	testType.equal<IsStrictFunction<never, 1, 2>, 2>(true)
-	testType.equal<IsStrictFunction<void, 1, 2>, 2>(true)
-})
diff --git a/type-plus/ts/function/strict_function_type.not_strict_function_type.spec.ts b/type-plus/ts/function/strict_function_type.not_strict_function_type.spec.ts
deleted file mode 100644
index a412a466d7..0000000000
--- a/type-plus/ts/function/strict_function_type.not_strict_function_type.spec.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type NotStrictFunctionType } from '../index.js'
-
-it('returns never if T is Function', () => {
-	testType.never<NotStrictFunctionType<Function>>(true)
-})
-
-it('returns T if T is function signature', () => {
-	testType.equal<NotStrictFunctionType<() => void>, () => void>(true)
-	testType.equal<NotStrictFunctionType<AnyFunction>, AnyFunction>(true)
-})
-
-it('returns T if T is function overloads', () => {
-	testType.equal<NotStrictFunctionType<{ (): void, (x: number): number }>, { (): void, (x: number): number }>(
-		true
-	)
-})
-it('returns T for special types', () => {
-	testType.equal<NotStrictFunctionType<void>, void>(true)
-	testType.equal<NotStrictFunctionType<unknown>, unknown>(true)
-	testType.equal<NotStrictFunctionType<any>, any>(true)
-	testType.equal<NotStrictFunctionType<never>, never>(true)
-})
-
-it('returns T for all other types', () => {
-	testType.equal<NotStrictFunctionType<undefined>, undefined>(true)
-	testType.equal<NotStrictFunctionType<null>, null>(true)
-	testType.equal<NotStrictFunctionType<boolean>, boolean>(true)
-	testType.equal<NotStrictFunctionType<true>, true>(true)
-	testType.equal<NotStrictFunctionType<false>, false>(true)
-	testType.equal<NotStrictFunctionType<number>, number>(true)
-	testType.equal<NotStrictFunctionType<1>, 1>(true)
-	testType.equal<NotStrictFunctionType<string>, string>(true)
-	testType.equal<NotStrictFunctionType<''>, ''>(true)
-	testType.equal<NotStrictFunctionType<symbol>, symbol>(true)
-	testType.equal<NotStrictFunctionType<bigint>, bigint>(true)
-	testType.equal<NotStrictFunctionType<1n>, 1n>(true)
-	testType.equal<NotStrictFunctionType<{}>, {}>(true)
-	testType.equal<NotStrictFunctionType<{ a: 1 }>, { a: 1 }>(true)
-	testType.equal<NotStrictFunctionType<string[]>, string[]>(true)
-	testType.equal<NotStrictFunctionType<[]>, []>(true)
-})
-
-it('returns T if T is union of function and other types', () => {
-	testType.equal<NotStrictFunctionType<Function | { a: 1 }>, Function | { a: 1 }>(true)
-})
-
-it('returns T if T is intersection of function', () => {
-	testType.equal<NotStrictFunctionType<Function & { a: 1 }>, Function & { a: 1 }>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<NotStrictFunctionType<Function, 1, 2>, 2>(true)
-	testType.equal<NotStrictFunctionType<{}, 1, 2>, 1>(true)
-
-	testType.equal<NotStrictFunctionType<any, 1, 2>, 1>(true)
-	testType.equal<NotStrictFunctionType<unknown, 1, 2>, 1>(true)
-	testType.equal<NotStrictFunctionType<never, 1, 2>, 1>(true)
-	testType.equal<NotStrictFunctionType<void, 1, 2>, 1>(true)
-})
diff --git a/type-plus/ts/function/strict_function_type.spec.ts b/type-plus/ts/function/strict_function_type.spec.ts
deleted file mode 100644
index fa1a7e3ef3..0000000000
--- a/type-plus/ts/function/strict_function_type.spec.ts
+++ /dev/null
@@ -1,60 +0,0 @@
-import { it } from '@jest/globals'
-import { testType, type AnyFunction, type StrictFunctionType } from '../index.js'
-
-it('returns T if T is Function', () => {
-	testType.equal<StrictFunctionType<Function>, Function>(true)
-})
-
-it('returns never if T is a function signature', () => {
-	testType.never<StrictFunctionType<() => void>>(true)
-	testType.never<StrictFunctionType<AnyFunction>>(true)
-})
-
-it('returns never if T is function overloads', () => {
-	testType.never<StrictFunctionType<{ (): void, (x: number): number }>>(true)
-	testType.never<StrictFunctionType<{ (): void, a: 1 }>>(true)
-})
-
-it('returns never for special types', () => {
-	testType.never<StrictFunctionType<void>>(true)
-	testType.never<StrictFunctionType<unknown>>(true)
-	testType.never<StrictFunctionType<any>>(true)
-	testType.never<StrictFunctionType<never>>(true)
-})
-
-it('returns never for other types', () => {
-	testType.never<StrictFunctionType<undefined>>(true)
-	testType.never<StrictFunctionType<null>>(true)
-	testType.never<StrictFunctionType<boolean>>(true)
-	testType.never<StrictFunctionType<true>>(true)
-	testType.never<StrictFunctionType<false>>(true)
-	testType.never<StrictFunctionType<number>>(true)
-	testType.never<StrictFunctionType<1>>(true)
-	testType.never<StrictFunctionType<string>>(true)
-	testType.never<StrictFunctionType<''>>(true)
-	testType.never<StrictFunctionType<symbol>>(true)
-	testType.never<StrictFunctionType<bigint>>(true)
-	testType.never<StrictFunctionType<1n>>(true)
-	testType.never<StrictFunctionType<{}>>(true)
-	testType.never<StrictFunctionType<{ a: 1 }>>(true)
-	testType.never<StrictFunctionType<string[]>>(true)
-	testType.never<StrictFunctionType<[]>>(true)
-})
-
-it('returns never if T is union of function and other types', () => {
-	testType.never<StrictFunctionType<Function | { a: 1 }>>(true)
-})
-
-it('returns never if T is intersection of function', () => {
-	testType.never<StrictFunctionType<Function & { a: 1 }>>(true)
-})
-
-it('can override Then/Else', () => {
-	testType.equal<StrictFunctionType<Function, 1, 2>, 1>(true)
-	testType.equal<StrictFunctionType<AnyFunction, 1, 2>, 2>(true)
-
-	testType.equal<StrictFunctionType<any, 1, 2>, 2>(true)
-	testType.equal<StrictFunctionType<unknown, 1, 2>, 2>(true)
-	testType.equal<StrictFunctionType<never, 1, 2>, 2>(true)
-	testType.equal<StrictFunctionType<void, 1, 2>, 2>(true)
-})
diff --git a/type-plus/ts/function/strict_function_type.ts b/type-plus/ts/function/strict_function_type.ts
deleted file mode 100644
index 5afea4792d..0000000000
--- a/type-plus/ts/function/strict_function_type.ts
+++ /dev/null
@@ -1,55 +0,0 @@
-import type { IsAnyOrNever } from '../mix_types/is_any_or_never.js'
-import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/selection.js'
-
-/**
- * Check if `T` is exactly `Function`.
- *
- * ```ts
- * type R = StrictFunctionType<Function> // Function
- *
- * type R = StrictFunctionType<() => void> // never
- * type R = StrictFunctionType<Function & { a: 1 }> // never
- * ```
- */
-export type StrictFunctionType<T, Then = T, Else = never> = IsAnyOrNever<
-	T,
-	$SelectionBranch> extends infer R
-	? R extends $Then ? Else
-	: R extends $Else ? [T, Function] extends [Function, T] ? Then : Else
-	: never : never
-
-/**
- * Check if `T` is not exactly `Function`.
- *
- * ```ts
- * type R = NotStrictFunctionType<Function> // never
- * type R = NotStrictFunctionType<() => void> // () => void
- *
- * type R = NotStrictFunctionType<Function & { a: 1 }> // Function & { a: 1 }
- * ```
- */
-export type NotStrictFunctionType<T, Then = T, Else = never> = StrictFunctionType<T, Else, Then>
-
-/**
- * Is `T` exactly `Function`.
- *
- * ```ts
- * type R = IsStrictFunction<Function> // true
- *
- * type R = IsStrictFunction<() => void> // false
- * type R = IsStrictFunction<(() => void) & { a: 1 }> // false
- * ```
- */
-export type IsStrictFunction<T, Then = true, Else = false> = StrictFunctionType<T, Then, Else>
-
-/**
- * Is `T` not exactly `Function`.
- *
- * ```ts
- * type R = IsNotStrictFunction<Function> // false
- *
- * type R = IsNotStrictFunction<() => void> // true
- * type R = IsNotStrictFunction<(() => void) & { a: 1 }> // true
- * ```
- */
-export type IsNotStrictFunction<T, Then = true, Else = false> = StrictFunctionType<T, Else, Then>
diff --git a/type-plus/ts/index.ts b/type-plus/ts/index.ts
index 548bf95430..9992e335bd 100644
--- a/type-plus/ts/index.ts
+++ b/type-plus/ts/index.ts
@@ -39,13 +39,10 @@ export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
 export type { Equal, IsEqual, IsNotEqual, NotEqual } from './equal/equal.js'
 export type { AnyFunction } from './function/any_function.js'
 export * from './function/extract_function.js'
-export type { FunctionType, IsFunction, IsNotFunction, NotFunctionType } from './function/function_type.js'
-export type {
-	IsNotStrictFunction,
-	IsStrictFunction,
-	NotStrictFunctionType,
-	StrictFunctionType
-} from './function/strict_function_type.js'
+export type * from './function/is_function.js'
+export type * from './function/is_not_function.js'
+export type * from './function/is_not_strict_function.js'
+export type * from './function/is_strict_function.js'
 export * from './functional/index.js'
 export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
 export type { Abs, Add, Decrement, GreaterThan, Increment, Max, Multiply, Subtract } from './math/index.js'
diff --git a/type-plus/ts/mix_types/box.ts b/type-plus/ts/mix_types/box.ts
index db1f513901..415272251f 100644
--- a/type-plus/ts/mix_types/box.ts
+++ b/type-plus/ts/mix_types/box.ts
@@ -1,6 +1,6 @@
 import type { IsBigint } from '../bigint/is_bigint.js'
 import type { IsBoolean } from '../boolean/is_boolean.js'
-import type { IsFunction } from '../function/function_type.js'
+import type { IsFunction } from '../function/is_function.js'
 import type { IsNumber } from '../number/is_number.js'
 import type { IsStrictObject } from '../object/is_strict_object.js'
 import type { IsString } from '../string/string_type.js'
@@ -28,34 +28,36 @@ import type { $Else, $SelectionBranch, $Then } from '../type_plus/branch/selecti
 export type Box<T, Options extends Box.Options = Box.DefaultOptions> =
 	IsFunction<
 		T,
-		Function,
-		IsStrictObject<
+		IsFunction.$Branch
+	> extends infer R
+	? R extends $Then ? Function
+	: IsStrictObject<
+		T,
+		Object,
+		T extends Record<any, any> ? T :
+		IsBoolean<
 			T,
-			Object,
-			T extends Record<any, any> ? T :
-			IsBoolean<
-				T,
-				$SelectionBranch
-			> extends infer R
-			? R extends $Then ? Boolean
-			: R extends $Else ? IsNumber<
-				T,
-				IsNumber.$Branch
-			> extends infer R
-			? R extends $Then ? Number
-			: R extends $Else ? IsString<
+			$SelectionBranch
+		> extends infer R
+		? R extends $Then ? Boolean
+		: R extends $Else ? IsNumber<
+			T,
+			IsNumber.$Branch
+		> extends infer R
+		? R extends $Then ? Number
+		: R extends $Else ? IsString<
+			T,
+			String,
+			IsSymbol<
 				T,
-				String,
-				IsSymbol<
-					T,
-					Symbol,
-					IsBigint<T, { $then: BigInt, $else: Options['$notBoxable'] }>
-				>
+				Symbol,
+				IsBigint<T, { $then: BigInt, $else: Options['$notBoxable'] }>
 			>
-			: never : never
-			: never : never
 		>
+		: never : never
+		: never : never
 	>
+	: never
 
 export namespace Box {
 	export type Options = {
diff --git a/type-plus/ts/type_plus/branch/select_invert_strict_with_distribute.ts b/type-plus/ts/type_plus/branch/select_invert_strict_with_distribute.ts
index 0f1e62e565..b3889f1c42 100644
--- a/type-plus/ts/type_plus/branch/select_invert_strict_with_distribute.ts
+++ b/type-plus/ts/type_plus/branch/select_invert_strict_with_distribute.ts
@@ -65,10 +65,8 @@ export type SelectInvertStrictWithDistribute<
 	? R extends $Then ? $ResolveSelection<$O, T, $Then>
 	: R extends $Else ? (
 		$ResolveOptions<[$O['distributive'], SelectInvertStrictWithDistribute.$Default['distributive']]> extends true
-		// ? (T extends U ? $ResolveSelection<$O, T, $Else> :
-		// 	U extends T ? $ResolveSelection<$O, T, $Else> : $ResolveSelection<$O, T, $Then>)
-		? [T, U] extends [U, T] ? $ResolveSelection<$O, T, $Else> : $ResolveSelection<$O, T, $Then>
-		: [T, U] extends [U, T] ? $ResolveSelection<$O, T, $Else> : $ResolveSelection<$O, T, $Then>
+		? SelectInvertStrictWithDistribute._D<T, U, $O>
+		: SelectInvertStrictWithDistribute._N<T, U, $O>
 	)
 	: never : never
 
@@ -76,4 +74,13 @@ export namespace SelectInvertStrictWithDistribute {
 	export type $Options = $SelectionOptions & $DistributiveOptions
 	export type $Default = $SelectionPredicate & $DistributiveDefault
 	export type $Branch = $SelectionBranch & $DistributiveDefault
+	export type _D<T, U, $O extends SelectInvertStrictWithDistribute.$Options> =
+		T extends U ? $ResolveSelection<$O, T, $Else>
+		: $ResolveSelection<$O, T, $Then>
+	// T extends U ? U extends T
+	// ? $ResolveSelection<$O, T, $Else>
+	// : $ResolveSelection<$O, T, $Then>
+	// : $ResolveSelection<$O, T, $Then>
+	export type _N<T, U, $O extends SelectInvertStrictWithDistribute.$Options> =
+		[T, U] extends [U, T] ? $ResolveSelection<$O, T, $Else> : $ResolveSelection<$O, T, $Then>
 }
diff --git a/type-plus/ts/type_plus/branch/select_strict_with_distribute.ts b/type-plus/ts/type_plus/branch/select_strict_with_distribute.ts
new file mode 100644
index 0000000000..51e54c2b43
--- /dev/null
+++ b/type-plus/ts/type_plus/branch/select_strict_with_distribute.ts
@@ -0,0 +1,84 @@
+import type { IsAnyOrNever } from '../../mix_types/is_any_or_never.js'
+import type { $ResolveOptions } from '../resolve_options.js'
+import type { $DistributiveDefault, $DistributiveOptions } from './distributive.js'
+import type { $Else, $ResolveSelection, $SelectionBranch, $SelectionOptions, $SelectionPredicate, $Then } from './selection.js'
+
+/**
+ * 🎭 *predicate*
+ * ㊙️ *internal*
+ *
+ * Validate if `T` is `U`.
+ *
+ * @example
+ * ```ts
+ * type R = SelectStrictWithDistribute<undefined, undefined> // true
+ *
+ * type R = SelectStrictWithDistribute<never, undefined> // false
+ * type R = SelectStrictWithDistribute<unknown, undefined> // false
+ * type R = SelectStrictWithDistribute<string | boolean, undefined> // false
+ *
+ * type R = SelectStrictWithDistribute<string | undefined, undefined> // boolean
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Filter to ensure `T` is `U`, otherwise returns `never`.
+ *
+ * @example
+ * ```ts
+ * type R = SelectStrictWithDistribute<undefined, undefined, { selection: 'filter' }> // undefined
+ *
+ * type R = SelectStrictWithDistribute<never, undefined, { selection: 'filter' }> // never
+ * type R = SelectStrictWithDistribute<unknown, undefined, { selection: 'filter' }> // never
+ * type R = SelectStrictWithDistribute<string | boolean, undefined, { selection: 'filter' }> // never
+ *
+ * type R = SelectStrictWithDistribute<string | undefined, undefined> // undefined
+ * ```
+ *
+ * 🔢 *customize*:
+ *
+ * Disable distribution of union types.
+ *
+ * ```ts
+ * type R = SelectStrictWithDistribute<undefined | 1, undefined> // boolean
+ * type R = SelectStrictWithDistribute<undefined | 1, undefined, { distributive: false }> // false
+ * ```
+ *
+ * 🔢 *customize*
+ *
+ * Use unique branch identifiers to allow precise processing of the result.
+ *
+ * @example
+ * ```ts
+ * type R = SelectStrictWithDistribute<undefined, undefined, $SelectionBranch> // $Then
+ * type R = SelectStrictWithDistribute<string, undefined, $SelectionBranch> // $Else
+ * ```
+ */
+export type SelectStrictWithDistribute<
+	T,
+	U,
+	$O extends SelectStrictWithDistribute.$Options = {}
+> = IsAnyOrNever<
+	T,
+	$SelectionBranch
+> extends infer R
+	? R extends $Then ? $ResolveSelection<$O, T, $Else>
+	: R extends $Else ? (
+		$ResolveOptions<[$O['distributive'], SelectStrictWithDistribute.$Default['distributive']]> extends true
+		? SelectStrictWithDistribute._D<T, U, $O>
+		: SelectStrictWithDistribute._N<T, U, $O>
+	)
+	: never : never
+
+export namespace SelectStrictWithDistribute {
+	export type $Options = $SelectionOptions & $DistributiveOptions
+	export type $Default = $SelectionPredicate & $DistributiveDefault
+	export type $Branch = $SelectionBranch & $DistributiveDefault
+	export type _D<T, U, $O extends SelectStrictWithDistribute.$Options> =
+		T extends U ? U extends T
+		? $ResolveSelection<$O, T, $Then>
+		: $ResolveSelection<$O, T, $Else>
+		: $ResolveSelection<$O, T, $Else>
+	export type _N<T, U, $O extends SelectStrictWithDistribute.$Options> =
+		[T, U] extends [U, T] ? $ResolveSelection<$O, T, $Then> : $ResolveSelection<$O, T, $Else>
+}