type-plus 6.3.0 → 6.5.0

package/ts/function/readme.md

@@ -0,0 +1,84 @@
+# Function
+
+`Function` is a type to represent functions.
+
+## Type Checking
+
+The `FunctionType<T>` and friends are used to check if a type is `Function` or not.
+
+They are loose type checks, meaning they match `Function` and function signatures,
+function overloads, as well as intersection types.
+
+```ts
+import type { FunctionType } from 'type-plus'
+
+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
+```
+
+- [`FunctionType<T, Then = T, Else = never>`](function_type.ts#L18): check if `T` is `Function` or Function literal.
+- [`IsFunction<T, Then = true, Else = false`](function_type.ts#L39): is `T` `Function`.
+- [`NotFunctionType<T, Then = T, Else = never>`](function_type.ts#L56): check if `T` is not `Function`.
+- [`IsNotFunction<T, Then = true, Else = false>`](function_type.ts#L72): is `T` not `Function`.
+
+---
+
+The `StrictFunctionType<T>` and friends are used to check if a type is exactly `Function` or not.
+
+They are strict type checks, meaning they match only the type `Function` only.
+
+```ts
+import type { StrictFunctionType } from 'type-plus'
+
+ * type R = StrictFunctionType<Function> // Function
+ *
+ * type R = StrictFunctionType<() => void> // never
+ * type R = StrictFunctionType<Function & { a: 1 }> // never
+```
+
+- [`StrictFunctionType<T, Then = T, Else = never>`](strict_function_type.ts#L15): check if `T` is exactly `Function`.
+- [`IsStrictFunction<T, Then = true, Else = false`](strict_function_type.ts#L33): is `T` exactly `Function`.
+- [`NotStrictFunctionType<T, Then = T, Else = never>`](strict_function_type.ts#L47): check if `T` is not exactly `Function`.
+- [`IsNotStrictFunction<T, Then = true, Else = false>`](strict_function_type.ts#L61): is `T` not exactly `Function`.
+
+---
+
+`AnyFunction` is a type to represent any function.
+
+You can also use it to build specific signatures.
+
+```ts
+import type { AnyFunction } from 'type-plus'
+
+type R = AnyFunction // (...args: any[]) => any
+type R = AnyFunction<[a: string, b: number], boolean> // (a: string, b: number) => boolean
+```
+
+---
+
+`ExtractFunction<T>` extracts the function type from a type.
+Note that it does not work with function overloads.
+
+```ts
+import type { ExtractFunction } from 'type-plus'
+
+type R = ExtractFunction<{
+  () => void
+  a: 1
+}> // () => void
+```
+
+---
+
+`extractFunction` is the function form of `ExtractFunction<T>`.
+
+## References
+
+- [mdn web docs: BigInt][mdn]
+
+[mdn]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt

package/ts/function/strict_function_type.ts

@@ -0,0 +1,61 @@
+import type { IsAnyOrNever } from '../any/any_or_never.js'
+
+/**
+ * Check if `T` is exactly `Function`.
+ *
+ * ```ts
+ * import type { StrictFunctionType } from 'type-plus'
+ *
+ * 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,
+	Else,
+	[T, Function] extends [Function, T] ? Then : Else
+>
+
+/**
+ * Check if `T` is not exactly `Function`.
+ *
+ * ```ts
+ * import type { NotStrictFunctionType } from 'type-plus'
+ *
+ * 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
+ * import type { IsStrictFunction } from 'type-plus'
+ *
+ * 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
+ * import type { IsNotStrictFunction } from 'type-plus'
+ *
+ * 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>

package/ts/functional/Maybe.ts

@@ -1,5 +1,5 @@
-import type { Brand } from '../nominal-types/index.js'
-import type { Equal } from '../predicates/index.js'
+import type { Brand } from '../nominal/index.js'
+import type { Equal } from '../equal/equal.js'
 import type { Widen } from '../utils/index.js'
 
 export type Maybe<T> = Just<T> | None<T>

package/ts/functional/compose.ts

@@ -1,5 +1,5 @@
-import type { Head, Last } from '../array_plus/index.js'
-import type { AnyFunction } from '../function/AnyFunction.js'
+import type { Head, Last } from '../array/index.js'
+import type { AnyFunction } from '../function/any_function.js'
 
 /**
  * Compose functions to produce a new function.

package/ts/index.ts

@@ -1,27 +1,100 @@
-// import * as types from './types/index.js'
 export { required, requiredDeep, unpartial } from 'unpartial'
-export type { ComposableTypes, NonComposableTypes } from './ComposableTypes.js'
-export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './JSONTypes.js'
-export type { IsNever, PrimitiveTypes } from './PrimitiveTypes.js'
-// export * from './types/optional.js'
-// export * from './types/required.js'
-export type { UnionKeys } from './UnionKeys.js'
-export * from './any_plus/index.js'
-export * as ArrayPlus from './array_plus/array_plus.js'
-export * from './array_plus/index.js'
-export * from './assertion/index.js'
+export type { IsAnyOrNever } from './any/any_or_never.js'
+export type { AnyType, IsAny, IsNotAny, NotAnyType } from './any/any_type.js'
+export type { At, Concat } from './array/array.js'
+export * as ArrayPlus from './array/array_plus.js'
+export type { ArrayType, IsArray, IsNotArray, NotArrayType } from './array/array_type.js'
+export * from './array/index.js'
+export * from './assertion/assert_type.js'
+export type { BigintType, IsBigint, IsNotBigint, NotBigintType } from './bigint/bigint_type.js'
+export type {
+	IsNotStrictBigint,
+	IsStrictBigint,
+	NotStrictBigintType,
+	StrictBigintType
+} from './bigint/strict_bigint_type.js'
+export type { BooleanType, IsBoolean, IsNotBoolean, NotBooleanType } from './boolean/boolean_type.js'
+export type { FalseType, IsFalse, IsNotFalse, NotFalseType } from './boolean/false_type.js'
+export type {
+	IsNotStrictBoolean,
+	IsStrictBoolean,
+	NotStrictBooleanType,
+	StrictBooleanType
+} from './boolean/strict_boolean_type.js'
+export type { IsNotTrue, IsTrue, NotTrueType, TrueType } from './boolean/true_type.js'
 export * from './class/index.js'
-export * from './function/index.js'
+export type { ComposableTypes, NonComposableTypes } from './composable_types.js'
+export type { Equal, 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 * from './functional/index.js'
-export type * from './math/index.js'
+export type { JSONArray, JSONObject, JSONPrimitive, JSONTypes } from './json.js'
+export type {
+	Abs,
+	Add,
+	Decrement,
+	Digit,
+	DigitArray,
+	GreaterThan,
+	Increment,
+	Max,
+	Subtract
+} from './math/index.js'
+export type { IsNever, IsNotNever, Is_Never, NeverType, NotNeverType, Not_Never } from './never/never_type.js'
 export * from './nodejs/index.js'
-export * from './nominal-types/index.js'
-export * from './number_plus/index.js'
-export * as NumberPlus from './number_plus/number_plus.js'
+export * from './nominal/index.js'
+export type { IsNotNull, IsNull, NotNullType, NullType } from './null/null_type.js'
+export type { Integer, IsInteger, IsNotInteger, IsWhole, NotInteger } from './number/integer.js'
+export type { IsNegative, IsNotNegative, Negative, NotNegative } from './number/negative.js'
+export * as NumberPlus from './number/number_plus.js'
+export type { IsNotNumber, IsNumber, NotNumberType, NumberType } from './number/number_type.js'
+export type {
+	IsNotNumeric,
+	IsNumeric,
+	NotNumericType,
+	Numeric,
+	NumericType,
+	Zero
+} from './number/numeric_type.js'
+export type { IsNotPositive, IsPositive, NonPositive, Positive } from './number/positive.js'
+export type {
+	IsNotStrictNumber,
+	IsStrictNumber,
+	NotStrictNumberType,
+	StrictNumberType
+} from './number/strict_number_type.js'
 export * from './object/index.js'
+export type { IsNotObject, IsObject, NotObjectType, ObjectType } from './object/object_type.js'
 export * from './predicates/index.js'
+export type { PrimitiveTypes } from './primitive.js'
 export * from './promise/index.js'
-export * from './testing/index.js'
-export * from './tuple/index.js'
+export type {
+	IsNotStrictString,
+	IsStrictString,
+	NotStrictStringType,
+	StrictStringType
+} from './string/strict_string_type.js'
+export type { IsNotString, IsString, NotStringType, StringType } from './string/string_type.js'
+export type { IsNotSymbol, IsSymbol, NotSymbolType, SymbolType } from './symbol/symbol_type.js'
+export * from './testing/stub.js'
+export * from './testing/test_type.js'
+export type { IsNotTuple, IsTuple, NotTupleType, TupleType } from './tuple/tuple_type.js'
+export type { Failed, FailedT } from './type/failed.js'
+export type {
+	IsNotUndefined,
+	IsUndefined,
+	NotUndefinedType,
+	UndefinedType
+} from './undefined/undefined_type.js'
+export type { UnionKeys } from './union_keys.js'
+export type { IsNotUnknown, IsUnknown, NotUnknownType, UnknownType } from './unknown/unknown_type.js'
 export * from './utils/index.js'
-// export { types, types as T }
+export type { IsNotVoid, IsVoid, NotVoidType, VoidType } from './void/void_type.js'
+

package/ts/math/Add.ts

@@ -1,6 +1,7 @@
-import type { PadLeft } from '../array_plus/index.js'
+import type { PadLeft } from '../array/index.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
 import type { And } from '../predicates/index.js'
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { Max } from './Max.js'
 
@@ -8,8 +9,8 @@ import type { Max } from './Max.js'
  * Add two number literals.
  */
 export type Add<A extends number, B extends number, Fail = never> = And<
-	And<IsPositive<A>, IsWhole<A>>,
-	And<IsPositive<B>, IsWhole<B>>
+	And<IsPositive<A>, IsInteger<A>>,
+	And<IsPositive<B>, IsInteger<B>>
 > extends false
 	? Fail
 	: DigitArray.FromNumber<A> extends infer DA

package/ts/math/Digit.ts

@@ -1,5 +1,6 @@
-import type { Tail } from '../array_plus/index.js'
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
+import type { Tail } from '../array/tail.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
 import type { And } from '../predicates/index.js'
 
 export namespace Digit {
@@ -66,7 +67,7 @@ export namespace DigitArray {
 	export type FromNumberAbs<N extends number> = FromString<TrimMinusSign<`${N}`>>
 	export type TrimMinusSign<N extends string> = N extends `-${infer rest}` ? rest : N
 
-	export type NumberToString<N extends number> = And<IsPositive<N>, IsWhole<N>> extends true ? `${N}` : never
+	export type NumberToString<N extends number> = And<IsPositive<N>, IsInteger<N>> extends true ? `${N}` : never
 
 	export type FromString<S extends string> = S extends `1${infer L}`
 		? [1, ...FromString<L>]

package/ts/math/GreaterThan.ts

@@ -1,12 +1,14 @@
-import type { Head, PadLeft, Tail } from '../array_plus/index.js'
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
-import type { And, Equal, Or, Xor } from '../predicates/index.js'
+import type { Head, PadLeft, Tail } from '../array/index.js'
+import type { Equal } from '../equal/equal.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
+import type { And, Or, Xor } from '../predicates/index.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { Max } from './Max.js'
 
 export type GreaterThan<A extends number, B extends number, Fail = never> = And<
-	IsWhole<A>,
-	IsWhole<B>
+	IsInteger<A>,
+	IsInteger<B>
 > extends false
 	? Fail
 	: number extends A

package/ts/math/Max.ts

@@ -1,4 +1,4 @@
-import type { Equal } from '../predicates/index.js'
+import { Equal } from '../equal/equal.js'
 import type { GreaterThan } from './GreaterThan.js'
 
 export type Max<A extends number, B extends number, Fail = never> = GreaterThan<A, B> extends infer Result

package/ts/math/Subtract.ts

@@ -1,13 +1,13 @@
-import type { PadLeft, Some, Tail } from '../array_plus/index.js'
+import type { PadLeft, Some, Tail } from '../array/index.js'
+import type { IsInteger } from '../number/integer.js'
+import type { IsPositive } from '../number/positive.js'
 import type { And } from '../predicates/index.js'
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-import type { IsPositive, IsWhole } from '../number_plus/number.js'
 import type { Digit, DigitArray } from './Digit.js'
 import type { Max } from './Max.js'
 
 export type Subtract<A extends number, B extends number, Fail = never> = And<
-	And<IsPositive<A>, IsWhole<A>>,
-	And<IsPositive<B>, IsWhole<B>>
+	And<IsPositive<A>, IsInteger<A>>,
+	And<IsPositive<B>, IsInteger<B>>
 > extends true
 	? DigitArray.Shift10<DigitArray.FromNumber<A>> extends infer DA
 		? DA extends number[]

package/ts/never/never_type.ts

@@ -0,0 +1,65 @@
+import type { Brand } from '../nominal/brand.js'
+
+
+/**
+ * This is a unique type used in the `Else` branch of `NeverType`.
+ */
+export type Not_Never = Brand<'not_never', symbol>
+
+/**
+ * This is a unique type used in the `Else` branch of `NotNeverType`.
+ */
+export type Is_Never = Brand<'is_never', symbol>
+
+/**
+ * Check if `T` is `never`.
+ * If it is not, returns `Not_Never`.
+ *
+ * ```ts
+ * import type { NeverType } from 'type-plus'
+ *
+ * type R = NeverType<never> // never
+ *
+ * type R = NeverType<1> // 'not never'
+ * ```
+ */
+export type NeverType<T, Then = T, Else = Not_Never> = [T, never] extends [never, T] ? Then : Else
+
+/**
+ * Check if `T` is not `never`.
+ * If it is not, returns `Is_Never`.
+ *
+ * ```ts
+ * import type { NotNeverType } from 'type-plus'
+ *
+ * type R = NotNeverType<1> // 1
+ *
+ * type R = NotNeverType<never> // 'is_never'
+ * ```
+ */
+export type NotNeverType<T, Then = T, Else = Is_Never> = NeverType<T, Else, Then>
+
+/**
+ * Is `T` `never`.
+ *
+ * ```
+ * import type { IsNever } from 'type-plus'
+ *
+ * type R = IsNever<never> // true
+ *
+ * type R = IsNever<1> // false
+ * ```
+ */
+export type IsNever<T, Then = true, Else = false> = NeverType<T, Then, Else>
+
+/**
+ * Is `T` not `never`.
+ *
+ * ```
+ * import type { IsNotNever } from 'type-plus'
+ *
+ * type R = IsNotNever<1> // true
+ *
+ * type R = IsNotNever<never> // false
+ */
+export type IsNotNever<T, Then = true, Else = false> = NeverType<T, Else, Then>

package/ts/never/readme.md

@@ -0,0 +1,37 @@
+# never
+
+`never` is a bottom type in TypeScript.
+That means it is a subtype of all other types.
+
+## Type Checking
+
+The `NeverType<T>` and friends are used to check if a type is exactly `never`.
+
+Filter normally returns `never` in the `Else` clause.
+But since we are checking for `never` here,
+they have to return something other than `never`.
+
+Therefore, `NeverType<T>` will return the `Not_Never` symbol when `T` is not `never`,
+and `NotNeverType<T>` will return the `Is_Never` symbol when `T` is `never`.
+
+```ts
+import type { NeverType } from 'type-plus'
+
+type R = NeverType<never> // never
+
+type R = NeverType<true> // Not_Never
+type R = NeverType<false> // Not_Never
+```
+
+- [`NeverType<T, Then = T, Else = Not_Never>`](never_type.ts#L16): check if `T` is exactly `never`.
+- [`IsNever<T, Then = true, Else = false`](never_type.ts#L50): is `T` exactly `never`.
+- [`NotNeverType<T, Then = T, Else = Is_Never>`](never_type.ts#L35): check if `T` is not exactly `never`.
+- [`IsNotNever<T, Then = true, Else = false>`](never_type.ts#L65): is `T` not exactly `never`.
+
+## References
+
+- [Handbook]
+- [TypeScript Deep Dive][deep_dive]
+
+[deep_dive]: https://basarat.gitbook.io/typescript/type-system/never
+[handbook]: https://www.typescriptlang.org/docs/handbook/2/functions.html#never

package/ts/nominal/brand.ts

@@ -0,0 +1,43 @@
+// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
+// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
+
+import { isType } from '../predicates/isType.js'
+import type { Widen } from '../utils/index.js'
+import { typeSym, valueSym } from './constants.js'
+
+/**
+ * Create a "branded" version of a type.
+ * TypeScript won't allow implicit conversion to this type
+ */
+export type Brand<B extends string, T = never> = [T] extends [null] | [undefined] | [symbol] | [void]
+	? Branded<B, T>
+	: Branded<B, T> & T
+
+/**
+ * A branded type of `B` with value of `T`.
+ */
+export interface Branded<B extends string, T> {
+	[typeSym]: B
+	[valueSym]: T
+}
+
+/**
+ * Creates a brand creator with the specified type.
+ */
+export function brand<B extends string>(type: B): <T>(subject: T) => Brand<B, Widen<T>>
+/**
+ * Creates a branded value of specified type.
+ */
+export function brand<B extends string, T>(type: B, subject: T): Brand<B, Widen<T>>
+export function brand(typeInput: string, subject?: unknown) {
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return brand(typeInput, subject)
+		}
+
+	if (isType<{ [typeSym]: string }>(subject, s => typeof s === 'object' && s !== null)) {
+		// if subject is not an object, the branding will exist only in type-level.
+		subject[typeSym] = typeInput
+	}
+	return subject
+}

package/ts/nominal/flavor.ts

@@ -0,0 +1,53 @@
+// By Drew Colthorp, <https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/#comment-604580>
+// <https://gist.github.com/dcolthorp/aa21cf87d847ae9942106435bf47565d>
+
+import { isType } from '../predicates/isType.js'
+import type { Widen } from '../utils/index.js'
+import { typeSym, valueSym } from './constants.js'
+
+/**
+ * Create a "flavored" version of a type.
+ * TypeScript will disallow mixing flavors,
+ * but will allow unflavored values of that type to be passed in where a flavored version is expected.
+ * This is a less restrictive form of branding.
+ */
+export type Flavor<F extends string, T> = [T] extends [null] | [undefined] | [symbol] | [void]
+	? FlavoredUnit<F, T>
+	: Flavored<F> & T
+
+/**
+ * A flavored type of `F`
+ */
+export interface Flavored<F extends string> {
+	[typeSym]?: F
+}
+
+/**
+ * A special flavored type for special types.
+ */
+export interface FlavoredUnit<F extends string, T> {
+	[typeSym]?: F
+	[valueSym]: T
+}
+
+/**
+ * Creates a brand creator with the specified type.
+ */
+export function flavor<F extends string>(type: F): <T>(subject: T) => Flavor<F, Widen<T>>
+/**
+ * Creates a branded value of specified type.
+ */
+export function flavor<F extends string, T>(type: F, subject: T): Flavor<F, Widen<T>>
+export function flavor(type: string, subject?: unknown) {
+	if (subject === undefined)
+		return function <T>(subject: T) {
+			return flavor(type, subject)
+		}
+
+	if (isType<{ [typeSym]: string }>(subject, s => typeof s === 'object' && s !== null)) {
+		// if subject is not an object, the branding will exist only in type-level.
+		subject[typeSym] = type
+	}
+
+	return subject
+}

package/ts/nominal/index.ts

@@ -0,0 +1,3 @@
+export * from './brand.js'
+export * from './flavor.js'
+export * from './nominal_match.js'

package/ts/nominal/nominal_match.ts

@@ -0,0 +1,22 @@
+import type { Brand } from './brand.js'
+import type { Flavor } from './flavor.js'
+import { typeSym } from './constants.js'
+
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown>,
+	b: Brand<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Flavor<A, unknown>,
+	b: Flavor<B, unknown>
+): boolean
+export function nominalMatch<A extends string, B extends A>(
+	a: Brand<A, unknown> | Flavor<A, unknown>,
+	b: Brand<B, unknown> | Flavor<B, unknown>
+) {
+	if (typeof a === 'object' && a !== null && typeof b === 'object' && b !== null)
+		return a[typeSym] === b[typeSym]
+	else {
+		return true
+	}
+}

package/ts/null/null_type.ts

@@ -0,0 +1,61 @@
+import type { IsAny } from '../any/any_type.js'
+
+/**
+ * Check if the type `T` is exactly `null`.
+ *
+ * ```
+ * import type { NullType } from 'type-plus'
+ *
+ * type R = NullType<null> // null
+ *
+ * type R = NullType<never> // never
+ * type R = NullType<unknown> // never
+ * type R = NullType<string | boolean> // never
+ * ```
+ */
+export type NullType<T, Then = T, Else = never> = IsAny<T, Else, [T, null] extends [null, T] ? Then : Else>
+
+/**
+ * Is the type `T` exactly `null`.
+ *
+ * ```
+ * import type { IsNull } from 'type-plus'
+ *
+ * type R = IsNull<null> // true
+ *
+ * type R = IsNull<never> // false
+ * type R = IsNull<unknown> // false
+ * type R = IsNull<string | boolean> // false
+ * ```
+ */
+export type IsNull<T, Then = true, Else = false> = NullType<T, Then, Else>
+
+/**
+ * Check if the type `T` is not exactly `null`.
+ *
+ * ```
+ * import type { NotNullType } from 'type-plus'
+ *
+ * type R = NotNullType<null> // never
+ *
+ * type R = NotNullType<never> // never
+ * type R = NotNullType<unknown> // unknown
+ * type R = NotNullType<string | boolean> // string | boolean
+ * ```
+ */
+export type NotNullType<T, Then = T, Else = never> = NullType<T, Else, Then>
+
+/**
+ * Is the type `T` not exactly `null`.
+ *
+ * ```
+ * import type { IsNotNull } from 'type-plus'
+ *
+ * type R = IsNotNull<null> // false
+ *
+ * type R = IsNotNull<never> // true
+ * type R = IsNotNull<unknown> // true
+ * type R = IsNotNull<string | boolean> // true
+ * ```
+ */
+export type IsNotNull<T, Then = true, Else = false> = NullType<T, Else, Then>