type-plus 6.8.1 → 7.0.0

package/README.md

@@ -9,15 +9,46 @@
 [![Visual Studio Code][vscode_image]][vscode_url]
 [![Wallaby.js][wallaby_image]][wallaby_url]
 
-Advance type utilities for [TypeScript].
-
-## Feature Highlights
-
-- [Type assertions](#type-assertions)
-- [Type Checking](#type-checking)
-- [Type Utilities](#type-utilities)
-- [Nominal Types](#nominal-types)
-- [Functional Types](#functional-types)
+More than 200 type utilities for [TypeScript].
+
+## Table of Contents
+
+1. [Assertion Function](#assertion-function)
+   1. [assertType](#asserttype)
+2. [Type Guard](#type-guard)
+3. [Type Utilities](#type-utilities)
+4. [Type Checking](#type-checking)
+   1. [any](#any)
+   2. [Array](#array)
+   3. [bigint](#bigint)
+   4. [boolean](#boolean)
+   5. [function](#function)
+   6. [never](#never)
+   7. [null](#null)
+   8. [number](#number)
+   9. [numeric](#numeric)
+   10. [object](#object)
+   11. [Promise](#promise)
+   12. [string](#string)
+   13. [symbol](#symbol)
+   14. [tuple](#tuple)
+   15. [undefined](#undefined)
+   16. [unknown](#unknown)
+   17. [void](#void)
+5. [Constant Types](#constant-types)
+6. [JSON Support](#json-support)
+7. [Type manipulation](#type-manipulation)
+8. [Type Predicates](#type-predicates)
+   1. [Logical](#logical)
+9. [Math](#math)
+10. [Utility Functions](#utility-functions)
+11. [Nominal Types](#nominal-types)
+12. [Functional Types](#functional-types)
+13. [Attribution](#attribution)
+14. [Useful Tips](#useful-tips)
+15. [Similar projects](#similar-projects)
+16. [Contribute](#contribute)
+17. [Wallaby.js](#wallabyjs)
 
 ## Installation
 
@@ -29,38 +60,29 @@ yarn add type-plus
 pnpm add type-plus
 ```
 
-## Type Assertions
+## Assertion Function
 
-Type assertion is one of the main features of `type-plus`.
+[Assertion Functions][assertion_functions] are special functions that asserts certain conditions of your program.
 
-Type assertions can be `immediate` compile time check, or they can have `runtime` behavior.
+It is introduced in TypeScript 3.7.
 
-There are 4 kinds of type assertions:
+They throw an error if the condition is not met, and return nothing otherwise.
 
-- `type guard`: [User-defined type guard functions][type_guard] (`if (isBool(s))`) introduced in TypeScript 1.6.
-- `assertion function`: [assertion functions][assertion_function] (`assertIsBool(a)`) introduced in TypeScript 3.7.
-- `logical`: functions or generic types that returns `true` or `false` type to be used in type level programming.
-- `filter`: generic type that returns `never` if the test fails.
+These assertion functions are typically used in runtime,
+so that that type of the value can be narrowed down.
 
-Here are the type assertions provided in `type-plus`.
-Use the one that fits your specific needs.
+### assertType
 
-`assertType<T>(subject)`:
+[`assertType`](./ts/assertion/assert_type.ts) provides a generic assertion function,
+as well as many assertion functions for builtin types.
 
-✔️ `immediate`
+> [`assertType<T>(subject)`](./ts/assertion/readme.md#asserttype)
 
-It ensures `subject` satisfies `T`.
-It is similar to `const x: T = subject` without introducing an unused variable.
-You need to specify `T` for it to work.
+💀 deprecated. Use `assertType.as()` instead.
 
 `assertType<T>(subject, validator)`:
 
-`assertType<T>(subject, Class)`:
-
-✔️ `assertion function`, `runtime`
-
-These overloads of `assertType` allow you to specify a `validator`.
-With these overloads, `subject` can be `unknown` or `any`.
+🚦`assertion`: assert the `subject` is type `T` with the specified `validator`.
 
 If `subject` fails the assertion,
 a standard `TypeError` will be thrown and provide better error info.
@@ -75,189 +97,169 @@ assertType<boolean>(s, s => typeof s === 'boolean')
 
 The message beautification is provided by [`tersify`](https://github.com/unional/tersify).
 
-`assertType.isUndefined(subject)`:
+> [`assertType.isUndefined()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.isNull(subject)`:
+🚦`assertion`: assert the `subject` is `undefined`.
 
-`assertType.isNumber(subject)`:
+> [`assertType.noUndefined()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.isBoolean(subject)`:
+🚦`assertion`: assert the `subject` is not `undefined`.
 
-`assertType.isTrue(subject)`:
+> [`assertType.isNull()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.isFalse(subject)`:
+🚦`assertion`: assert the `subject` is `null`.
 
-`assertType.isString(subject)`:
+> [`assertType.noNull()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.isFunction(subject)`:
+🚦`assertion`: assert the `subject` is not `null`.
 
-`assertType.isConstructor(subject)`:
+> [`assertType.isNumber()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.isError(subject)`:
+🚦`assertion`: assert the `subject` is `number`.
 
-✔️ `immediate`, `assertion function`, `runtime`
+> [`assertType.noNumber()`](./ts/assertion/readme.md#asserttype)
 
-Compiler and runtime assertion with type narrowing from `any`.
-They assert the type of `subject` is that specific type.
-i.e. union type will fail at type level:
+🚦`assertion`: assert the `subject` is not `number`.
 
-```ts
-const s: number | undefined = undefined
-assertType.isUndefined(s) // TypeScript complains
-```
+> [`assertType.isBoolean()`](./ts/assertion/readme.md#asserttype)
 
-They accept `any` and will be narrowed to the specific type.
+🚦`assertion`: assert the `subject` is `boolean`.
 
-```ts
-const s: any = undefined
-assertType.isUndefined(s)
-s // type is undefined
-```
+> [`assertType.noBoolean()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.isNever(subject)`:
+🚦`assertion`: assert the `subject` is not `boolean`.
 
-✔️ `immediate`
+> [`assertType.isTrue()`](./ts/assertion/readme.md#asserttype)
 
-Check if the subject type is `never`.
-This function is not very useful in actual code as TypeScript will indicate the error.
-But it can be useful when writing tests for types.
+🚦`assertion`: assert the `subject` is `true`.
 
-This is useful for variables. For type level only check, do the following:
+> [`assertType.noTrue()`](./ts/assertion/readme.md#asserttype)
 
-```ts
-assertType.isTrue(true as Equal<YourType, never>)
-```
+🚦`assertion`: assert the `subject` is not `true`.
 
-`assertType.noUndefined(subject)`:
+> [`assertType.isFalse()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.noNull(subject)`:
+🚦`assertion`: assert the `subject` is `false`.
 
-`assertType.noNumber(subject)`:
+> [`assertType.noFalse()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.noBoolean(subject)`:
+🚦`assertion`: assert the `subject` is not `false`.
 
-`assertType.noTrue(subject)`:
+> [`assertType.isString()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.noFalse(subject)`:
+🚦`assertion`: assert the `subject` is `string`.
 
-`assertType.noString(subject)`:
+> [`assertType.noString()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.noFunction(subject)`:
+🚦`assertion`: assert the `subject` is not `string`.
 
-`assertType.noError(subject)`:
+> [`assertType.isFunction()`](./ts/assertion/readme.md#asserttype)
 
-✔️ `immediate`, `runtime`
+🚦`assertion`: assert the `subject` is `function`.
 
-Compiler and runtime assertion.
-Assert `subject` type does not contain the specific type.
-Work against unions.
+> [`assertType.noFunction()`](./ts/assertion/readme.md#asserttype)
 
-```ts
-const s: number | undefined = 1
-assertType.noUndefined(s) // TypeScript complains
-```
+🚦`assertion`: assert the `subject` is not `function`.
 
-They accept `subject` with type `any` or `unknown`,
-the assertion will happen in runtime to ensure `subject` is the specific type.
+> [`assertType.isError()`](./ts/assertion/readme.md#asserttype)
 
-`assertType.as<T>(subject)`:
+🚦`assertion`: assert the `subject` is an `Error`.
 
-✔️ `immediate`
+> [`assertType.noError()`](./ts/assertion/readme.md#asserttype)
 
-Assert `subject` as `T` inline.
-This is useful to help TypeScript to adjust the type on the fly.
+🚦`assertion`: assert the `subject` is not an `Error`.
 
-```ts
-let s: number | undefined = 1
-assertType.as<1>(s) // `s` type is now `1`
-```
+> [`assertType.isConstructor()`](./ts/assertion/readme.md#asserttype)
 
-`isType<T>(subject: T)`:
+💀 deprecated. It does not work in all cases.
 
-✔️ `immediate`
+It passes for function that can be called with `new`.
+If the subject is an arrow function, it can still return true after compilation.
 
-It ensures `subject` satisfies `T`.
-It is identical to `assertType<T>(subject: T)`.
-You need to specify `T`.
+> [`assertType.isNever()`](./ts/assertion/readme.md#asserttype)
 
-`isType<T>(subject, validator)`:
+🚦`assertion`: assert the `subject` is `never`.
 
-`isType<T>(subject, Class)`:
+> [`assertType.custom()`](./ts/assertion/readme.md#asserttype)
 
-`isType.t<T>(subject?: T)`:
+🚦`assertion`: creates a custom assertion function.
 
-✔️ `immediate`, `runtime`
+Using it to create a custom assertion function that provides better error messages.
 
-It can be used as type check: `isType.t<Equal<A, B>>()`,
-or value type check: `isType.t(valueTypeIsTrue)`.
-It returns `true` when passes (which is the only case when used in TypeScript).
+The message beautification is provided by [`tersify`](https://github.com/unional/tersify).
 
-`isType.f<T>(subject?: T)`:
+> [`assertType.as<T>()`](./ts/assertion/readme.md#asserttype)
 
-✔️ `immediate`, `runtime`
+🚦`assertion`: assert the `subject` as `T` without validator.
 
-It can be used as type check: `isType.f<Equal<A, B>>()`,
-or value type check: `isType.f(valueTypeIsFalse)`.
-It returns `true` when passes (which is the only case when used in TypeScript).
+This works similar to manual assertion `;(subject as T)`
 
-`isType.equal<true|false, A, B>()`:
+## Type Guard
 
-✔️ `immediate`
+[User-defined type guard functions][type_guard] is a function which its return type is specified as `x is T`.
 
-Slightly easier to use then `isType.t<>()` and `isType.f<>()`,
-when doing type-level only equality comparison as you don't have to import `Equal<>`.
+> [`isType()`](./ts/type-guard/readme.md#istype)
 
-✔️ `type guard`, `runtime`
+🛡️ `guard`: a generic type guard function
 
-These overloads of `isType` allow you to specify a `validator`.
-With these overloads, `subject` can be `unknown` or `any`.
+> [`isType.t()`](./ts/type-guard/readme.md#istype)
 
-[`isType.never<S>()`](ts/predicates/isType.ts#L25):
+💀 `deprecated`: use `testType.true()` instead.
 
-✔️ `immediate`
+> [`isType.f()`](./ts/type-guard/readme.md#istype)
 
-Check is the type `never`.
+💀 `deprecated`: use `testType.false()` instead.
 
-[`isType.never(s)`](ts/predicates/isType.ts#L29):
+> [`isType.never()`](./ts/type-guard/readme.md#istype)
 
-✔️ `immediate`
+💀 `deprecated`: use `testType.never()` instead.
 
-Check is the value is type `never`.
+> [`isType.equal()`](./ts/type-guard/readme.md#istype)
 
-`Equal<A, B>`:
-`IsEqual<A, B>`:
+💀 `deprecated`: use `testType.equal()` instead.
 
-✔️ `logical`
+## Type Utilities
 
-Check if `A` and `B` are the same.
+> `Equal<A, B, Then = true, Else = false>`
 
-`NotEqual<A, B>`:
-`IsNotEqual<A, B>`:
+💀 deprecated. use `IsEqual` instead. This will be converted to a ↪️ `parse`.
 
-✔️ `logical`
+> `IsEqual<A, B, Then = true, Else = false>`
 
-Check if `A` and `B` are not the same.
+⭕ `predicate`: if `A` and `B` are the same.
 
-`IsExtend<A, B>`:
-`IsNotExtend<A, B>`:
+> `NotEqual<A, B, Then = true, Else = false>`
 
-✔️ `logical`
+💀 deprecated. use `IsNotEqual` instead. This will be converted to a ↪️ `parse`.
 
-Check if `A` extends or not extends `B`.
+> `IsNotEqual<A, B, Then = true, Else = false>`:
 
-`Extendable<A, B>`:
-`NotExtendable<A, B>`:
+⭕ `predicate`: check if `A` and `B` are not the same.
 
-✔️ `filter`
+> `Extendable<A, B, Then = A, Else = never>`
 
-Check if `A` extends or not extends `B`.
+↪️ `parse`: check if `A` extends `B`.
 
-`IsAssign<A, B>`:
-`CanAssign<A, B>`:
+> `IsExtend<A, B, Then = true, Else = false>`
 
-✔️ `logical`
+⭕ `predicate`: check if `A` extends `B`.
+
+> `NotExtendable<A, B, Then = A, Else = never>`:
+
+↪️ `parse`: check if `A` not extends `B`.
+
+> `IsNotExtend<A, B, Then = true, Else = false>`:
+
+⭕ `predicate`: check if `A` not extends `B`.
+
+> `IsAssign<A, B, Then = true, Else = false>`
+
+💀 `deprecated`: use `CanAssign` instead.
+
+> `CanAssign<A, B, Then = true, Else = false>`:
+
+⭕ `predicate`: check can `A` assign to `B`.
 
-Check if `A` can be assigned to `B`.
 A typical usage is using it with `assertType`:
 
 ```ts
@@ -265,9 +267,20 @@ assertType.isFalse(false as CanAssign<boolean, { a: string }>)
 assertType.isTrue(true as CanAssign<{ a:string, b:number }, { a: string }>)
 ```
 
-`canAssign<T>(): (subject) => true`:
+> `StrictCanAssign<A, B, Then = true, Else = false>`
 
-✔️ `immediate`, `logical`
+⭕ `predicate`: can `A` strictly assign to `B`
+
+When `A` is a union, all branches must be assignable to `B`.
+
+```ts
+StrictCanAssign<number | string, number> // false
+StrictCanAssign<number | string, number | string> // true
+```
+
+> `canAssign<T>(): (subject) => true`
+
+⭕💻 `predicate`, `compile-time`
 
 Returns a compile-time validating function to ensure `subject` is assignable to `T`.
 
@@ -276,9 +289,9 @@ const isConfig = canAssign<{ a: string }>()
 assertType.isTrue(isConfig({ a: 'a' }))
 ```
 
-`canAssign<T>(false): (subject) => false`:
+> `canAssign<T>(false): (subject) => false`:
 
-✔️ `immediate`, `logical`
+⭕💻 `predicate`, `compile-time`
 
 Returns a compile-time validating function to ensure `subject` is not assignable to `T`.
 
@@ -289,17 +302,6 @@ assertType.isTrue(notA({ a: 1 }))
 notA({ a: '' }) // TypeScript complains
 ```
 
-`IsNever<T>`:
-
-✔️ `logical`
-
-Check if `A` is `never`.
-
-```ts
-IsNever<never> // true
-IsNever<1>     // false
-```
-
 ## Type Checking
 
 [type-plus](./README.md) privides type checking utilities for every type.
@@ -327,71 +329,600 @@ You can learn more in their respective sections:
 - [unknown](./ts/unknown/readme.md)
 - [void](./ts/void/readme.md)
 
-## Type Utilities
+### any
 
-`type-plus` also provides additional type utilities.
-These utilities include utility types and type-adjusted functions.
+> [`AnyType<T>`](./ts/any/readme.md#type-checking)
 
-Note that most `predicate` types (such as `IsAny<>`) have a `Then` and `Else` that you can override.
+↪️ `parse`: `T === any`.
 
-e.g.:
+> [`IsAny<T>`](./ts/any/readme.md#type-checking)
 
-```ts
-type Yes = IsAny<any, 'yes', 'no'> // 'yes'
-type No = IsAny<1, 'yes', 'no'> // 'no'
-```
+⭕ `predicate`: `T === any`.
+
+> [`NotAnyType<T>`](./ts/any/readme.md#type-checking)
+
+↪️ `parse`: `T !== any`.
+
+> [`IsNotAny<T>`](./ts/any/readme.md#type-checking)
 
-### Any
+⭕ `predicate`: `T !== any`.
 
-- [`AnyType<T, Then = T, Else = never>`](ts/any_plus/any.ts#L14): `T === any`.
-- [`IsAny<T, Then = true, Else = false>`](ts/any_plus/any.ts#L29): `T === any` (origin: [ts-essentials]).
+> [`IsAnyOrNever<T>`](./ts/any/readme.md#type-utilities)
+
+⭕ `predicate`: `T === any || T === never`.
 
 ### Array
 
-- [`At<A, N, Fail = never>`](ts/array_plus/array.ts#L19): gets the element type at index `N` in the array `A`.
-- `CommonPropKeys<A>`: gets common keys inside the records in the array `A` (deprecate `CommonKeys`).
-- [`Concat<A, B>`](ts/array_plus/array.ts#L38): `[...A, ...B]`.
-- `CreateTuple<L, T>`: Creates `Tuple<T>` with `L` number of elements.
-- `drop(array, value)`: drop a particular value from an array.
-- `DropFirst<A>`: drops the first value type of `A`.
-- `DropLast<A>`: drops the last value type of `A`.
-- `DropMatch<A, Criteria>`: drops entries matching `Criteria` in array or tuple `A`.
-- `DropUndefined<A>`: drop undefined entries from array of tuple `A`.
-- `Filter<A, Criteria>`: filter the array or tuple `A`, keeping entries satisfying `Criteria`. **Deprecated. Renaming to `KeepMatch`**
-- `FindFirst<A, Criteria>`: gets the first type satisfying `Criteria`.
-- `FindLast<A, Criteria>`: gets the last type satisfying `Criteria`.
-- `Head<A>`: gets the first entry in the array.
-- `IntersectOfProps<A, K>`: gets the intersect of `A[K]` types (deprecate `MapToProp`)
-- `IsArray<T>`: `logical` predicate for `Array`.
-- `KeepMatch<A, Criteria>`: keeps entries satisfying `Criteria` in array or tuple `A`.
-- `Last<A>`: gets the last type of array or tuple.
-- `literalArray(...entries)`: return an array whose items are restricted to the provided literals.
-- `PadLeft<A, Total, PadWith>`: pads `A` with `PadWith` if the length of `A` is less than `L`.
-- `reduceWhile()`: `reduce()` with predicate for early termination. \
+> [`ArrayType<T>`](./ts/array/readme.md#type-checking)
+
+↪️ `parse`: is the type `T` exactly an array and not a tuple.
+
+> [`IsArray<T>`](./ts/array/readme.md#type-checking)
+
+⭕ `predicate`: is the type `T` exactly an array and not a tuple.
+
+> [`NotArrayType<T>`](./ts/array/readme.md#type-checking)
+
+↪️ `parse`: is the type `T` not an array or tuple.
+
+> [`IsNotArray<T>`](./ts/array/readme.md#type-checking)
+
+⭕ `predicate`: is the type `T` exactly an array and not a tuple.
+
+> [`At<A, N, Fail = never>`](ts/array_plus/array.ts#L19)
+
+🔨 `utilities`: gets the element type at index `N` in the array `A`.
+
+> `CommonPropKeys<A>`
+
+🔨 `utilities`: gets common keys inside the records in the array `A` (deprecate `CommonKeys`).
+
+> [`Concat<A, B>`](ts/array_plus/array.ts#L38)
+
+🔨 `utilities`: `[...A, ...B]`.
+
+> `CreateTuple<L, T>`
+
+🔨 `utilities`: creates `tuple<T>` with `L` number of elements.
+
+> `drop(array, value)`
+
+🔨 `utilities`: drop a particular value from an array.
+
+> `DropFirst<A>`
+
+🔨 `utilities`: drops the first value type of `A`.
+
+> `DropLast<A>`
+
+🔨 `utilities`: drops the last value type of `A`.
+
+> `DropMatch<A, Criteria>`
+
+🔨 `utilities`: drops entries matching `Criteria` in array or tuple `A`.
+
+> `DropUndefined<A>`
+
+🔨 `utilities`: drop undefined entries from array of tuple `A`.
+
+> `Filter<A, Criteria>`
+
+💀🔨 `deprecated`,`utilities`: filter the array or tuple `A`, keeping entries satisfying `Criteria`. **Deprecated. Renaming to `KeepMatch`**
+
+> `FindFirst<A, Criteria>`
+
+🔨 `utilities`: gets the first type satisfying `Criteria`.
+
+> `FindLast<A, Criteria>`
+
+🔨 `utilities`: gets the last type satisfying `Criteria`.
+
+> `Head<A>`
+
+🔨 `utilities`: gets the first entry in the array.
+
+> `IntersectOfProps<A, K>`
+
+🔨 `utilities`: gets the intersect of `A[K]` types (deprecate `MapToProp`)
+
+> `KeepMatch<A, Criteria>`
+
+🔨 `utilities`: keeps entries satisfying `Criteria` in array or tuple `A`.
+
+> `Last<A>`
+
+🔨 `utilities`: gets the last type of array or tuple.
+
+> `literalArray(...entries)`
+
+🔨 `utilities`: return an array whose items are restricted to the provided literals.
+
+> `PadLeft<A, Total, PadWith>`
+
+🔨 `utilities`: pads `A` with `PadWith` if the length of `A` is less than `L`.
+
+> `reduceWhile()`
+
+🔨 `utilities`: `reduce()` with predicate for early termination. \
   A simple version of the same function in the `ramda` package.
-- `Reverse<A>`: reverses the order of `A`.
-- `Some<A, Criteria>`: true if some elements in `A` matches `Criteria`.
-- `Tail<A>`: Gets the types of a tuple except the first entry.
-- `UnionOfProps<A, K>`: gets the union of `A[K]` types (deprecate `PropUnion`).
-- `UnionOfValues<A>`: gets the union of value types in `A` (deprecate `ArrayValue`).
-- [`ArrayPlus.IndexAt<A, N, Fail = never>`](ts/array_plus/array_plus.ts#L23): gets the normalized index for `A`.
-- [`ArrayPlus.IsIndexOutOfBound<A, N, Then = true, Else = false>`](ts/array_plus/array_plus.ts#L62): Is `N` an out of bound index of `A`. Supports negative numbers.
-- [`ArrayType<T, Then = N, Else = never>`](ts/array_plus/array.ts#L48): Is the type `T` exactly an array and not a tuple.
-
-### Constant Types
-
-- `KeyTypes`: type of all keys.
-- `PrimitiveTypes`: all primitive types, including `Function`, `symbol`, and `bigint`.
-- `ComposableTypes`: Types that can contain custom properties. i.e. `object`, `array`, `function`.
-- `NonComposableTypes`: Types that cannot contain custom properties. i.e. not composable.
-
-### JSON Support
-
-- `JSONPrimitive`: primitive types valid in JSON
-- `JSONObject`: JSON object
-- `JSONArray`: JSON array
-- `JSONTypes`: all JSON compatible types.
-- `JSONTypes.get<T>(obj, ...props)`: get a cast value in JSON
+
+> `Reverse<A>`
+
+🔨 `utilities`: reverses the order of `A`.
+
+> `Some<A, Criteria>`
+
+🔨 `utilities`: true if some elements in `A` matches `Criteria`.
+
+> `Tail<A>`
+
+🔨 `utilities`: Gets the types of a tuple except the first entry.
+
+> `UnionOfProps<A, K>`
+
+🔨 `utilities`: gets the union of `A[K]` types (deprecate `PropUnion`).
+
+> `UnionOfValues<A>`
+
+🔨 `utilities`: gets the union of value types in `A` (deprecate `ArrayValue`).
+
+> [`ArrayPlus.IndexAt<A, N, Fail = never>`](ts/array_plus/array_plus.ts#L23)
+
+🔨 `utilities`: gets the normalized index for `A`.
+
+> [`ArrayPlus.IsIndexOutOfBound<A, N, Then = true, Else = false>`](ts/array_plus/array_plus.ts#L62)
+
+⭕ `predicate`: is `N` an out of bound index of `A`. Supports negative numbers.
+
+### bigint
+
+> [`BigintType<T, Then = T, Else = never>`](./ts/bigint/bigint_type.ts#L15)
+
+↪️ `parse`: if `T` is `bigint` or bigint literal.
+
+> [`IsBigint<T, Then = true, Else = false>`](./ts/bigint/bigint_type.ts#L33)
+
+⭕ `predicate`: if `T` is `bigint` or bigint literal.
+
+> [`NotBigintType<T, Then = T, Else = never>`](./ts/bigint/bigint_type.ts#L47)
+
+↪️ `parse`: if `T` is not `bigint` or bigint literal.
+
+> [`IsNotBigInt<T, Then = true, Else = false>`](./ts/bigint/bigint_type.ts#L61)
+
+⭕ `predicate`: if `T` is not `bigint` or bigint literal.
+
+> [`StrictBigintType<T, Then = T, Else = never>`](./ts/bigint/strict_bigint_type.ts#L15)
+
+↪️ `parse`: if `T` is exactly `bigint`.
+
+> [`IsStrictBigint<T, Then = true, Else = false>`](./ts/bigint/strict_bigint_type.ts#L33)
+
+⭕ `predicate`: if `T` is exactly `bigint`.
+
+> [`NotStrictBigintType<T, Then = T, Else = never>`](./ts/bigint/strict_bigint_type.ts#L47)
+
+↪️ `parse`: if `T` is not exactly `bigint`.
+
+> [`IsNotStrictBigint<T, Then = true, Else = false>`](./ts/bigint/strict_bigint_type.ts#L61)
+
+⭕ `predicate`: if `T` is not exactly `bigint`.
+
+### boolean
+
+> [`BooleanType<T>`](./ts/boolean/readme.md#type-checking)
+
+↪️ `parse`: `T === boolean`.
+
+> [`IsBoolean<T>`](./ts/boolean/readme.md#type-checking)
+
+⭕ `predicate`: `T === boolean`
+
+> [`NotBooleanType<T>`](./ts/boolean/readme.md#type-checking)
+
+↪️ `parse`: `T !== boolean`.
+
+> [`IsNotBoolean<T>`](./ts/boolean/readme.md#type-checking)
+
+⭕ `predicate`: `T !== boolean`
+
+### function
+
+> [`FunctionType<T>`](./ts/function/readme.md#type-checking)
+
+↪️ `parse`: `T === function`.
+
+> [`IsFunction<T>`](./ts/function/readme.md#type-checking)
+
+⭕ `predicate`: `T === function`
+
+> [`NotFunctionType<T>`](./ts/function/readme.md#type-checking)
+
+↪️ `parse`: `T !== function`.
+
+> [`IsNotFunction<T>`](./ts/function/readme.md#type-checking)
+
+⭕ `predicate`: `T !== function`
+
+> `AnyFunction<P, R>`
+
+🔨 `utilities`: a generic type for any function
+
+> `ExtractFunction<F>`
+
+🔨 `utilities`: extract the function signature from a type `F`.
+
+> `extractFunction(fn: F)`
+
+🔨 `utilities`: adjust type of `fn` to its function signature only.
+
+> `inspect<T>(value: T, inspector?: (v: T) => void)`
+
+🔨 `utilities`: inspect a value and return it. Inspector defaults to `console.dir()`
+
+### never
+
+> [`NeverType<T>`](./ts/never/readme.md#type-checking)
+
+↪️ `parse`: `T === never`.
+
+> [`IsNever<T>`](./ts/never/readme.md#type-checking)
+
+⭕ `predicate`: `T === never`
+
+> [`NotNeverType<T>`](./ts/never/readme.md#type-checking)
+
+↪️ `parse`: `T !== never`.
+
+> [`IsNotNever<T>`](./ts/never/readme.md#type-checking)
+
+⭕ `predicate`: `T !== never`
+
+### null
+
+> [`NullType<T>`](./ts/null/readme.md#type-checking)
+
+↪️ `parse`: `T === null`.
+
+> [`IsNull<T>`](./ts/null/readme.md#type-checking)
+
+⭕ `predicate`: `T === null`
+
+> [`NotNullType<T>`](./ts/null/readme.md#type-checking)
+
+↪️ `parse`: `T !== null`.
+
+> [`IsNotNull<T>`](./ts/null/readme.md#type-checking)
+
+⭕ `predicate`: `T !== null`
+
+### number
+
+> [`NumberType<T, Then = N, Else = never>`](./ts/number/number_type.ts#L14)
+
+↪️ `parse`: is the type `T` `number`.
+
+> [`IsNumber<T, Then = true, Else = false>`](./ts/number/number_type.ts#L27)
+
+⭕ `predicate`: is the type `T` `number`.
+
+> [`NotNumberType<T, Then = T, Else = never>`](./ts/number/number_type.ts#L40)
+
+↪️ `parse`: is the type `T` not `number`.
+
+> [`IsNotNumber<T, Then = true, Else = false>`](./ts/number/number_type.ts#L53)
+
+⭕ `predicate`: is the type `T` not `number`.
+
+> [`StrictNumberType<T, Then = N, Else = never>`](./ts/number/strict_number_type.ts#L19)
+
+↪️ `parse`: is the type `T` exactly `number`.
+
+> [`IsStrictNumber<T, Then = true, Else = false>`](./ts/number/strict_number_type.ts#L41)
+
+⭕ `predicate`: is the type `T` exactly `number`.
+
+> [`NotStrictNumberType<T, Then = T, Else = never>`](./ts/number/strict_number_type.ts#L55)
+
+↪️ `parse`: is the type `T` not exactly `number`.
+
+> [`IsNotStrictNumber<T, Then = true, Else = false>`](./ts/number/strict_number_type.ts#L69)
+
+⭕ `predicate`: is the type `T` not exactly `number`.
+
+### numeric
+
+> [`Numeric`](./ts/numeric/numeric_type.ts#L4)
+
+📘 `definition`: `number | bigint`.
+
+> [`Zero`](ts/numeric_plus/numeric_type.ts#L9)
+
+📘 `definition`: `0 | 0n`
+
+> [`Integer<N, Then = N, Else = never>`](./ts/numeric/integer.ts#L15)
+
+↪️ `parse`: is integer.
+
+> [`IsInteger<N, Then = true, Else = false>`](./ts/numeric/integer.ts#L32)
+
+⭕ `predicate`: is integer.
+
+> [`NotInteger<N, Then = N, Else = never>`](./ts/numeric/integer.ts#L45)
+
+↪️ `parse`: is not integer.
+
+> [`IsNotInteger<N, Then = true, Else = false>`](./ts/numeric/integer.ts#L60)
+
+⭕ `predicate`: is not integer.
+
+> [`IsWhole<N, Then = true, Else = false>`](./ts/numeric/integer.ts#L75)
+
+💀⭕ `deprecated`, `predicate`: is integer. Use `IsInteger` instead.
+
+> [`Negative<N, Then = N, Else = never>`](./ts/numeric/negative.ts#L19)
+
+↪️ `parse`: is negative.
+
+> [`IsNegative<N, Then = true, Else = false>`](./ts/numeric/negative.ts#L53)
+
+⭕ `predicate`: is negative.
+
+> [`NonNegative<N, Then = N, Else = never>`](./ts/numeric/negative.ts#L69)
+
+↪️ `parse`: is not negative.
+
+> [`IsNonNegative<N, Then = N, Else = never>`](./ts/numeric/negative.ts#L101)
+
+⭕ `predicate`: is not negative.
+
+> [`Positive<N, Then = N, Else = never>`](./ts/numeric/positive.ts#15)
+
+↪️ `parse`: is positive.
+
+> [`IsPositive<N, Then = true, Else = false>`](./ts/numeric/positive.ts#L36)
+
+⭕ `predicate`: is positive.
+
+> [`NotPositive<N, Then = N, Else = never>`](./ts/numeric/positive.ts#48)
+
+↪️ `parse`: is not positive.
+
+> [`IsNotPositive<N, Then = true, Else = false>`](./ts/numeric/positive.ts#L60)
+
+⭕ `predicate`: is not positive.
+
+### object
+
+> `filterKey()`
+
+🔨 `utilities`: type adjusted filter by key.
+
+> `findKey()`
+
+🔨 `utilities`: type adjusted find by key.
+
+> `forEachKey()`
+
+🔨 `utilities`: type adjusted for each by key.
+
+> `HasKey<T, K>`
+
+🔨 `utilities`: predicate type checking `T` has key `K`.
+
+> `hasKey()`
+
+🔨 `utilities`: function of `HasKey`.
+
+> `IsRecord<T>`
+
+🔨 `utilities`: `logical` predicate for `Record`.
+
+> `KeysWithDiffTypes<A, B>`
+
+🔨 `utilities`: gets the keys common in `A` and `B` but with different value type.
+
+> `mapKey()`
+
+🔨 `utilities`: type adjusted map by key.
+
+> `RecordValue<R>`
+
+🔨 `utilities`: gets the value type `T`from `Record<any, T>`
+
+[video](https://www.youtube.com/watch?v=1J7xK6FUqPw).
+
+> `reduceByKey()`
+
+🔨 `utilities`: type adjusted reduce by key.
+
+> `someKey()`
+
+🔨 `utilities`: type adjusted some by key.
+
+> `SpreadRecord<A, B>`
+
+🔨 `utilities`: type for `{...a, ...b}` when both `a` and `b` are `Record`\
+  for array, just do `[...A, ...B]`.
+
+### Promise
+
+> `AwaitedProp<T, V>`
+
+🔨 `utilities`: `Awaited` on specified props `P` in `T`.
+
+> `isPromise<R>(subject: any)`
+
+🔨 `utilities`: `isPromise()` type guard.
+
+> `MaybePromise<T>`
+
+🔨 `utilities`: Alias of `T | Promise<T>`.
+
+> `PromiseValue<P>`
+
+🔨 `utilities`: Gets the type within the Promise.
+
+> `PromiseValueMerge<P1, P2, ...P9>`
+
+🔨 `utilities`: Merge the values of multiple promises.
+
+> `mapSeries()`
+
+🔨 `utilities`: Similar to `bluebird.mapSeries()` but works with `async`/`await`.
+
+> `transformMaybePromise(value, transformer)`
+
+🔨 `utilities`: Apply the `transformer` to the `value`.\
+  It is also exported under `MaybePromise.transform()`.
+
+### string
+
+> [`StringType<T>`](ts/string/readme.md#type-checking)
+
+↪️ `parse`: is `string`.
+
+> [`IsString<T>`](ts/string/readme.md#type-checking)
+
+⭕ `predicate`: is `string`.
+
+> [`NotStringType<T>`](ts/string/readme.md#type-checking)
+
+↪️ `parse`: is not `string`.
+
+> [`IsNotString<T>`](ts/string/readme.md#type-checking)
+
+⭕ `predicate`: is not `string`.
+
+### symbol
+
+> [`SymbolType<T>`](ts/symbol/readme.md#type-checking)
+
+↪️ `parse`: is `symbol`.
+
+> [`IsSymbol<T>`](ts/symbol/readme.md#type-checking)
+
+⭕ `predicate`: is `symbol`.
+
+> [`NotSymbolType<T>`](ts/symbol/readme.md#type-checking)
+
+↪️ `parse`: is not `symbol`.
+
+> [`IsNotSymbol<T>`](ts/symbol/readme.md#type-checking)
+
+⭕ `predicate`: is not `symbol`.
+
+### tuple
+
+> [`TupleType<T>`](ts/tuple/readme.md#type-checking)
+
+↪️ `parse`: is a tuple.
+
+> [`IsTuple<T>`](ts/tuple/readme.md#type-checking)
+
+⭕ `predicate`: is a tuple.
+
+> [`NotTupleType<T>`](ts/tuple/readme.md#type-checking)
+
+↪️ `parse`: is not a tuple.
+
+> [`IsNotTuple<T>`](ts/tuple/readme.md#type-checking)
+
+⭕ `predicate`: is not a tuple.
+
+### undefined
+
+> [`UndefinedType<T>`](./ts/undefined/readme.md#type-checking)
+
+↪️ `parse`: `T === undefined`.
+
+> [`IsUndefined<T>`](./ts/undefined/readme.md#type-checking)
+
+⭕ `predicate`: `T === undefined`
+
+> [`NotUndefinedType<T>`](./ts/undefined/readme.md#type-checking)
+
+↪️ `parse`: `T !== undefined`.
+
+> [`IsNotUndefined<T>`](./ts/undefined/readme.md#type-checking)
+
+⭕ `predicate`: `T !== undefined`
+
+### unknown
+
+> [`UnknownType<T>`](./ts/unknown/readme.md#type-checking)
+
+↪️ `parse`: `T === unknown`.
+
+> [`IsUnknown<T>`](./ts/unknown/readme.md#type-checking)
+
+⭕ `predicate`: `T === unknown`
+
+> [`NotUnknownType<T>`](./ts/unknown/readme.md#type-checking)
+
+↪️ `parse`: `T !== unknown`.
+
+> [`IsNotUnknown<T>`](./ts/unknown/readme.md#type-checking)
+
+⭕ `predicate`: `T !== unknown`
+
+### void
+
+> [`VoidType<T>`](./ts/void/readme.md#type-checking)
+
+↪️ `parse`: `T === void`.
+
+> [`IsVoid<T>`](./ts/void/readme.md#type-checking)
+
+⭕ `predicate`: `T === void`
+
+> [`NotVoidType<T>`](./ts/void/readme.md#type-checking)
+
+↪️ `parse`: `T !== void`.
+
+> [`IsNotVoid<T>`](./ts/void/readme.md#type-checking)
+
+⭕ `predicate`: `T !== void`
+
+## Constant Types
+
+> `KeyTypes`
+
+📘 `definition`: type of all keys.
+
+> `PrimitiveTypes`
+
+📘 `definition`: all primitive types, including `Function`, `symbol`, and `bigint`.
+
+> `ComposableTypes`
+
+📘 `definition`: Types that can contain custom properties. i.e. `object`, `array`, `function`.
+
+> `NonComposableTypes`
+
+📘 `definition`: Types that cannot contain custom properties. i.e. not composable.
+
+## JSON Support
+
+> `JSONPrimitive`
+
+📘 `definition`: primitive types valid in JSON
+
+> `JSONObject`
+
+📘 `definition`: JSON object
+
+> `JSONArray`
+
+📘 `definition`: JSON array
+
+> `JSONTypes`
+
+📘 `definition`: all JSON compatible types.
+
+> `JSONTypes.get<T>(obj, ...props)`
+
+🔨 `utilities`: get a cast value in JSON
 
 ```ts
 import { JSONTypes } from 'type-plus'
@@ -401,144 +932,303 @@ const someJson: JSONTypes = { a: { b: ['z', { c: 'miku' }]}}
 JSONTypes.get<string>(someJson, 'a', 'b', 1, 'c') // miku
 ```
 
-### Object utilities
-
-- `filterKey()`: type adjusted filter by key.
-- `findKey()`: type adjusted find by key.
-- `forEachKey()`: type adjusted for each by key.
-- `HasKey<T, K>`: predicate type checking `T` has key `K`.
-- `hasKey()`: function of `HasKey`.
-- `IsRecord<T>`: `logical` predicate for `Record`.
-- `KeysWithDiffTypes<A, B>`: gets the keys common in `A` and `B` but with different value type.
-- `mapKey()`: type adjusted map by key.
-- `RecordValue<R>`: gets the value type `T`from `Record<any, T>` [video](https://www.youtube.com/watch?v=1J7xK6FUqPw).
-- `reduceByKey()`: type adjusted reduce by key.
-- `someKey()`: type adjusted some by key.
-- `SpreadRecord<A, B>`: type for `{...a, ...b}` when both `a` and `b` are `Record`\
-  for array, just do `[...A, ...B]`.
+## Type manipulation
 
-### Promise utilities
+> `ANotB<A, B>`
 
-- `AwaitedProp<T, V>`: `Awaited` on specified props `P` in `T`.
-- `isPromise<R>(subject: any)`: `isPromise()` type guard.
-- `MaybePromise<T>`: Alias of `T | Promise<T>`.
-- `PromiseValue<P>`: Gets the type within the Promise.
-- `PromiseValueMerge<P1, P2, ...P9>`: Merge the values of multiple promises.
-- `mapSeries()`: Similar to `bluebird.mapSeries()` but works with `async`/`await`.
-- `transformMaybePromise(value, transformer)`: Apply the `transformer` to the `value`.\
-  It is also exported under `MaybePromise.transform()`.
+🔨 `utilities`: get object with properties in `A` and not in `B`, including properties with a different value type.
+
+> `BNotA<A, B>`
+
+🔨 `utilities`: flip of `ANotB`
+
+> `as<T>(subject)`
+
+🔨 `utilities`: assert `subject` as `T`. Avoid ASI issues such as `;(x as T).abc`
+
+> `asAny(subject)`
+
+🔨 `utilities`: assert `subject` as `any`. Avoid ASI issue such as `;(x as any).abc`
+
+> `EitherAnd<A, B, [C, D]>`
+
+💀🔨 `deprecated`,`utilities`: Renamed to `EitherOrBoth`. combines 2 to 4 types as `A | B | (A & B)`.
+
+This is useful for combining options.
+
+> `EitherOrBoth<A, B, [C, D]>`
+
+🔨 `utilities`: combines 2 to 4 types as `A | B | (A & B)`.
+
+This is useful for combining options [video](https://youtu.be/jBxx03NT4Ik).
+
+> `Except<T, K>`
+
+💀🔨 `deprecated`,`utilities`: same as `Omit<T, K>`.
+
+> `ExcludePropType<T, U>`
+
+🔨 `utilities`: excludes type `U` from properties in `T`.
+
+> `KeyofOptional<T>`
+
+🔨 `utilities`: `keyof` that works with `Record<any, any> | undefined`.
+
+> `KnownKeys<T>`
+
+🔨 `utilities`: extract known (defined) keys from type `T`.
+
+> `LeftJoin<A, B>`
+
+🔨 `utilities`: left join `A` with `B`
+
+> `NonNull<T>`
+
+🔨 `utilities`: remove `null`
+
+> `NonNullable<T>` (built-in)
+
+🔨 `utilities`: adjust the type not to nullable
+
+> `NonUndefined<T>`
+
+🔨 `utilities`: remove `undefined`
+
+> `Omit<T, K>`
+
+🔨 `utilities`: From `T`, pick a set of properties whose keys are not in the union `K`. This is the opposite of `Pick<T, K>`.
+
+> `OptionalKeys<T>`
+
+🔨 `utilities`: gets keys of optional properties in `T`.
+
+> `PartialExcept<T, U>`
+
+💀🔨 `deprecated`,`utilities`: same as `PartialOmit<T, U>`.
+
+> `PartialOmit<T, U>`
+
+🔨 `utilities`: makes the properties not specified in `U` becomes optional.
+
+> `PartialPick<T, U>`
+
+🔨 `utilities`: makes the properties specified in `U` becomes optional.
+
+> `Pick<T, K>`
+
+🔨 `utilities`: pick properties `K` from `T`. Works with unions.
+
+> `RecursivePartial<T>`
 
-### Type manipulation
-
-- `ANotB<A, B>`: get object with properties in `A` and not in `B`, including properties with a different value type.
-- `BNotA<A, B>`: flip of `ANotB`
-- `as<T>(subject)`: assert `subject` as `T`. Avoid ASI issues such as `;(x as T).abc`
-- `asAny(subject)`: assert `subject` as `any`. Avoid ASI issue such as `;(x as any).abc`
-- `EitherAnd<A, B, [C, D]>`: combines 2 to 4 types as `A | B | (A & B)`. This is useful for combining options. **Deprecated**. Renamed to `EitherOrBoth`.
-- `EitherOrBoth<A, B, [C, D]>`: combines 2 to 4 types as `A | B | (A & B)`. This is useful for combining options [video](https://youtu.be/jBxx03NT4Ik).
-- `Except<T, K>`: Deprecated. Same as `Omit<T, K>`.
-- `ExcludePropType<T, U>`: excludes type `U` from properties in `T`.
-- `KeyofOptional<T>`: `keyof` that works with `Record<any, any> | undefined`.
-- `KnownKeys<T>`: extract known (defined) keys from type `T`.
-- `LeftJoin<A, B>`: left join `A` with `B`
-- `NonNull<T>`: remove `null`
-- `NonUndefined<T>`: remove `undefined`
-- `Omit<T, K>`: From `T`, pick a set of properties whose keys are not in the union `K`. This is the opposite of `Pick<T, K>`.
-- `OptionalKeys<T>`: gets keys of optional properties in `T`.
-- `PartialExcept<T, U>`: Deprecated. Same as `PartialOmit<T, U>`.
-- `PartialOmit<T, U>`: makes the properties not specified in `U` becomes optional.
-- `PartialPick<T, U>`: makes the properties specified in `U` becomes optional.
-- `Pick<T, K>`: pick properties `K` from `T`. Works with unions.
-- `RecursivePartial<T>`: make type `T` optional recursively.
-- `RecursiveRequired<T>`: make type `T` required recursively.
-- `ReplaceProperty<T, K, V>`: replace property `K` in `T` with `V`.
-- `RequiredKeys<T>`: gets keys of required properties in `T`.
-- `RequiredPick<T, U>`: makes the properties specified in `U` become required.
-- `RequiredExcept<T, U>`: makes the properties not specified in `U` become required.
-- `RecursiveIntersect<T, U>`: intersect type `U` onto `T` recursively.
-- `ValueOf<T>`: type of the value of the properties of `T`.
-- `Widen<T>`: widen literal types.
-- PropType: ...no helper type for this. Just do `YourType['propName']`.
-
-### Type Predicates
+🔨 `utilities`: make type `T` optional recursively.
+
+> `RecursiveRequired<T>`
+
+🔨 `utilities`: make type `T` required recursively.
+
+> `ReplaceProperty<T, K, V>`
+
+🔨 `utilities`: replace property `K` in `T` with `V`.
+
+> `RequiredKeys<T>`
+
+🔨 `utilities`: gets keys of required properties in `T`.
+
+> `RequiredPick<T, U>`
+
+🔨 `utilities`: makes the properties specified in `U` become required.
+
+> `RequiredExcept<T, U>`
+
+🔨 `utilities`: makes the properties not specified in `U` become required.
+
+> `RecursiveIntersect<T, U>`
+
+🔨 `utilities`: intersect type `U` onto `T` recursively.
+
+> `ValueOf<T>`
+
+🔨 `utilities`: type of the value of the properties of `T`.
+
+> `Widen<T>`
+
+🔨 `utilities`: widen literal types.
+
+PropType
+
+💀 ...no helper type for this. Just do `YourType['propName']`.
+
+## Type Predicates
 
 Type predicates are type alias that returns `true` or `false`.
 They can be used to compose complex types.
 
-- `HasKey<T, K>`: predicate type checking `T` has key `K`.
-- `IsAny<T>`: `T === any` (updated to impl: [expect-type]).
-- `IsBoolean<T>`: check for `boolean`, but not for `true` nor `false`.
-- `IsDisjoint<A, B>`: is `A` and `B` is a disjoint set.
-- `IsEmptyObject<T>`: is `T === {}`.
-- `IsLiteral<T>`: is `T` a literal type (literal string or number).
+> `HasKey<T, K>`
+
+🔨 `utilities`: predicate type checking `T` has key `K`.
+
+> `IsAny<T>`
+
+🔨 `utilities`: `T === any` (updated to impl: [expect-type]).
+
+> `IsBoolean<T>`
+
+🔨 `utilities`: check for `boolean`, but not for `true` nor `false`.
+
+> `IsDisjoint<A, B>`
+
+🔨 `utilities`: is `A` and `B` is a disjoint set.
+
+> `IsEmptyObject<T>`
+
+🔨 `utilities`: is `T === {}`.
+
+> `IsLiteral<T>`
+
+🔨 `utilities`: is `T` a literal type (literal string or number).
+
+### Logical
 
-#### Logical
+> `If<Condition, Then = true, Else = false>`
 
-- `If<Condition, Then = true, Else = false>`: if statement.
-- `And<A, B, Then = true, Else = false>`: logical `AND`.
-- `Or<A, B, Then = true, Else = false>`: logical `OR`.
-- `Xor<A, B, Then = true, Else = false>`: logical `XOR`.
-- `Not<X, Then = true, Else = false>`: logical `NOT`.
+🔨 `utilities`: if statement
+
+> `And<A, B, Then = true, Else = false>`
+
+🔨 `utilities`: logical `AND`
+
+> `Or<A, B, Then = true, Else = false>`
+
+🔨 `utilities`: logical `OR`
+
+> `Xor<A, B, Then = true, Else = false>`
+
+🔨 `utilities`: logical `XOR`
+
+> `Not<X, Then = true, Else = false>`
+
+🔨 `utilities`: logical `NOT`
 
 Note that these types work correctly with the `boolean` type.
 e.g.:
 
-- `And<boolean, true> -> boolean`
-- `Not<boolean> -> boolean`
+```ts
+type R = And<boolean, true> // boolean
+type R = Not<boolean>       // boolean`
+```
 
 There is a problem with generic distribution: <https://github.com/microsoft/TypeScript/issues/41053>
 So you may encounter some weird behavior if your logic is complex.
 
-### Number
-
-- [`Numeric`](ts/number_plus/number.ts#L4): either `number` or `bigint` (origin: [type-fest]).
-- [`Zero`](ts/number_plus/number.ts#L9): `0` in `number` or `bigint` (origin: [type-fest]).
-- [`Integer<N, Then = N, Else = never>`](ts/number_plus/number.ts#L27): is integer (origin: [type-fest]).
-- [`IsInteger<N, Then = true, Else = false>`](ts/number_plus/number.ts#L46): is integer.
-- [`IsWhole<N, Then = true, Else = false>`](ts/number_plus/number.ts#L62): is integer.
-- [`Negative<N, Then = N, Else = never>`](ts/number_plus/number.ts#L77): is negative (origin: [type-fest]).
-- [`NonNegative<N, Then = N, Else = never>`](ts/number_plus/number.ts#L96): is non-negative (origin: [type-fest])
-- [`NumberType<T, Then = N, Else = never>`](ts/number_plus/number.ts#L108): Is the type `T` exactly `number`.
-- [`Positive<N, Then = N, Else = never>`](ts/number_plus/number.ts#L124): is positive.
-- [`IsPositive<N, Then = N, Else = never>`](ts/number_plus/number.ts#L144): is positive.
-
-### Math
-
-- `Abs<N, Fail=never>`: `Abs(N)`, `Abs<number>` returns `Fail`.
-- `Max<A, B, Fail=never>`: `max(A, B)`, for whole number, `Fail` otherwise.
-- `GreaterThan<A, B, Fail=never>`: `A > B` for whole numbers, `Fail` otherwise.
-
-#### Arithmetic
-
-- `Add<A, B, Fail=never>`: `A + B` for positive and whole numbers, `Fail` otherwise.
-- `Subtract<A, B, Fail=never>`: `A - B` for positive and whole numbers, `Fail` otherwise.
-- `Increment<A, Fail=never>`: alias of `Add<A, 1, Fail>`.
-- `Decrement<A, Fail=never>`: alias of `Subtract<A, 1, Fail>`.
-
-### Tuple
-
-- [`TupleType`](ts/tuple/readme.md#tupletype)
-
-### Utility Functions
-
-- `amend(subject)...`: amend subject as union or intersect of `T`.
-- `facade(subject, ...props)`: create a facade of `subject`.
-- `getField(subject, key, defaultValue)`: get a field from a subject. Works against nullable and optional subject.
-- `hasKey()`: function of `HasKey`.
-- `hasProperty(value, prop)`: assert `value` has property `prop`. This will pick the correct union type.
-- `isConstructor(subject)`: type guard `subject` is a constructor.
-- `isSystemError(code, err)`: type guard `err` with NodeJS error code.
-- `omit(obj, ...props)`: omit properties from `obj`.
-- `pick(obj, ...props)`: pick properties from `obj`.
-- `record<K, V>(value?)`: create a `Record<K, V>` without extra object prototype.
-- `record<R>(value?)`: create a record `R` (e.g. `{ a: number }`) without extra object prototype.
-- `required(...)`: merge options and remove `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
-- `requiredDeep(...)`: merge options deeply and remove `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
-- `split(target, ...splitters)`: split one object into multiple objects.
-- `stub<T>(value)`: stub a particular type `T`.
-- `stub.build<T>(init?)`: build a stub for particular type `T`.
-- `typeOverrideIncompatible<T>()`: override only the incompatible portion between two types.
-- `unpartial()`: merge options and remove `Partial<T>` values. From [`unpartial`](https://github.com/unional/unpartial)
+## Math
+
+The math types in `type-plus` works with most numeric types.
+
+It works with `number` and `bigint`, positive and negative number, including floating point numbers.
+
+It will cast the type between `number` and `bigint` if needed.
+
+> `Abs<N, Fail = never>`
+
+🔨 `utilities`: `Abs(N)`.
+
+> `Max<A, B, Fail = never>`
+
+🔨 `utilities`: `max(A, B)`
+
+> `GreaterThan<A, B>`
+
+🔨 `utilities`: `A > B`.
+
+> `Add<A, B>`
+
+🔨 `utilities`: `A + B`.
+
+> `Subtract<A, B>`
+
+🔨 `utilities`: `A > B`.
+
+> `Increment<A>`
+
+🔨 `utilities`: alias of `Add<A, 1>`.
+
+> `Decrement<A>`
+
+🔨 `utilities`: alias of `Subtract<A, 1>`.
+
+> `Multiply<A, B`
+
+🔨 `utilities`: `A * B`.
+
+## Utility Functions
+
+> `amend(subject)...`
+
+🔨 `utilities`: amend subject as union or intersect of `T`.
+
+> `facade(subject, ...props)`
+
+🔨 `utilities`: create a facade of `subject`.
+
+> `getField(subject, key, defaultValue)`
+
+🔨 `utilities`: get a field from a subject. Works against nullable and optional subject.
+
+> `hasKey()`
+
+🔨 `utilities`: function of `HasKey`.
+
+> `hasProperty(value, prop)`
+
+🔨 `utilities`: assert `value` has property `prop`. This will pick the correct union type.
+
+> `isConstructor(subject)`
+
+🔨 `utilities`: type guard `subject` is a constructor.
+
+> `isSystemError(code, err)`
+
+🔨 `utilities`: type guard `err` with NodeJS error code.
+
+> `omit(obj, ...props)`
+
+🔨 `utilities`: omit properties from `obj`.
+
+> `pick(obj, ...props)`
+
+🔨 `utilities`: pick properties from `obj`.
+
+> `record<K, V>(value?)`
+
+🔨 `utilities`: create a `Record<K, V>` without extra object prototype.
+
+> `record<R>(value?)`
+
+🔨 `utilities`: create a record `R` (e.g. `{ a: number }`) without extra object prototype.
+
+> `required(...)`
+
+🔨 `utilities`: merge options and remove `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
+
+> `requiredDeep(...)`
+
+🔨 `utilities`: merge options deeply and remove `Partial<T>`. From [`unpartial`](https://github.com/unional/unpartial)
+
+> `split(target, ...splitters)`
+
+🔨 `utilities`: split one object into multiple objects.
+
+> `stub<T>(value)`
+
+🔨 `utilities`: stub a particular type `T`.
+
+> `stub.build<T>(init?)`
+
+🔨 `utilities`: build a stub for particular type `T`.
+
+> `typeOverrideIncompatible<T>()`
+
+🔨 `utilities`: override only the incompatible portion between two types.
 
 ```ts
 type A =  {
@@ -558,6 +1248,26 @@ const source = {
 overrider(source, { foo: !!source.foo })
 ```
 
+> `unpartial()`
+
+🔨 `utilities`: merge options and remove `Partial<T>` values. From [`unpartial`](https://github.com/unional/unpartial)
+
+> `context()`
+
+🔨 `utilities`: a context builder.
+
+This is useful to build context for functional programming.
+It is a sync version of the `AsyncContext` from [async-fp](https://unional/async-fp).
+
+```ts
+import { context } from 'type-plus'
+
+// { a: 1, b: 2 }
+const ctx = context({ a: 1 })
+  .extend(c => ({ b: c.a + 1 }))
+  .build()
+```
+
 ## Nominal Types
 
 The TypeScript type system is structural.
@@ -608,7 +1318,9 @@ but `Flavor` of the same name cannot be assigned to `Brand`.
 
 `nominalMatch(a, b)`:
 
-`nominalMatch()` can be used to compare `Brand` or `Flavor`.
+🔨 `utilities`: compare if the two values are nominally equal.
+
+Works with both `Brand` and `Flavor`.
 
 ```ts
 const b1 = brand('x', 1)
@@ -617,32 +1329,15 @@ const b2 = brand('y', 1)
 nominalMatch(b1, b2) // false
 ```
 
-## Function Utilties
-
-- `AnyFunction<P, R>`: a generic type for any function
-- `ExtractFunction<F>`: extract the function signature from a type `F`.
-- `extractFunction(fn: F)`: adjust type of `fn` to its function signature only.
-- `inspect<T>(value: T, inspector?: (v: T) => void)`: inspect a value and return it.\
-  Inspector defaults to `console.dir()`
-
 ## Functional Types
 
-- `ChainFn<T>: T`: chain function that returns the input type.
-- `compose(...fns): F`: compose functions
+> `ChainFn<T>: T`
 
-## Context Builder
+🔨 `utilities`: chain function that returns the input type.
 
-- `context()`: a context builder. This is useful to build context for functional programming.\
-  It is a sync version of the `AsyncContext` from [async-fp](https://unional/async-fp).
+> `compose(...fns): F`
 
-```ts
-import { context } from 'type-plus'
-
-// { a: 1, b: 2 }
-const ctx = context({ a: 1 })
-  .extend(c => ({ b: c.a + 1 }))
-  .build()
-```
+🔨 `utilities`: compose functions
 
 ## Attribution
 
@@ -650,6 +1345,10 @@ Some code in this library is created by other people in the TypeScript community
 I'm merely adding them in and maybe making some adjustments.
 Whenever possible, I add attribution to the person who created those **codes** in the file.
 
+## Useful Tips
+
+> <https://github.com/microsoft/TypeScript/wiki/Performance>
+
 ## Similar projects
 
 - [expect-type]: Compile-time tests for types
@@ -692,7 +1391,6 @@ test results immediately as you type, and see the results in
 your editor right next to your code.
 
 [@gcanti]: https://github.com/gcanti
-[assertion_function]: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions
 [codecov_image]: https://codecov.io/gh/unional/type-plus/branch/master/graph/badge.svg
 [codecov_url]: https://codecov.io/gh/unional/type-plus
 [downloads_image]: https://img.shields.io/npm/dm/type-plus.svg?style=flat
@@ -706,7 +1404,6 @@ your editor right next to your code.
 [ts-essentials]: https://github.com/ts-essentials/ts-essentials
 [ts-expect]: https://github.com/TypeStrong/ts-expect
 [ts-toolbelt]: https://github.com/millsp/ts-toolbelt
-[type_guard]: https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates
 [type-fest]: https://github.com/sindresorhus/type-fest
 [type-zoo]: https://github.com/pelotom/type-zoo
 [typelevel-ts]: https://github.com/gcanti/typelevel-ts
@@ -719,3 +1416,5 @@ your editor right next to your code.
 [wallaby_image]: https://img.shields.io/badge/wallaby.js-powered-blue.svg?style=flat&logo=github
 [wallaby_image_lg]: https://img.shields.io/badge/wallaby.js-powered-blue.svg?style=for-the-badge&logo=github
 [wallaby_url]: https://wallabyjs.com/oss/
+[assertion_functions]: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-7.html#assertion-functions
+[type_guard]: https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates