type-plus 7.5.0 → 8.0.0-beta.0

package/ts/array/array_plus.split_at.ts

@@ -1,45 +1,74 @@
-import type { IndexAt } from './array_index.js'
+import type { NeverType } from '../never/never_type.js'
+import type { IsTuple } from '../tuple/tuple_type.js'
+import type { IndexAt } from './array_plus.index_at.js'
 import type { ArrayType } from './array_type.js'
 
 /**
- * Splits an array into two at the specified `Index`.
+ * ⚗️ *transform*
+ *
+ * Splits array or tuple `A` into two at the specified `Index`.
  *
  * If the `Index` is out of bounds,
- * it will set to the boundary value, similar to `array.splice()`.
+ * it will set to the boundary value.
+ *
+ * It is the type level `splice()`.
  *
  * @example
  * ```ts
- * SplitAt<[1, 2, 3, 4, 5], 0> // [[], [1, 2, 3, 4, 5]]
- * SplitAt<[1, 2, 3, 4, 5], -5> // [[], [1, 2, 3, 4, 5]]
- *
  * SplitAt<[1, 2, 3, 4, 5], 2> // [[1, 2], [3, 4, 5]]
+ * SplitAt<[1, 2, 3, 4, 5], -3> // [[1, 2], [3, 4, 5]]
  *
- * SplitAt<[1, 2, 3, 4, 5], 4> // [[1, 2, 3, 4], [5]]
- * SplitAt<[1, 2, 3, 4, 5], -1> // [[1, 2, 3, 4], [5]]
+ * SplitAt<[1, 2, 3, 4, 5], 2, 2> // [[1, 2, 5], [3, 4]]
  *
- * SplitAt<[1, 2, 3, 4, 5], 5> // [[1, 2, 3, 4, 5], []]
+ * SplitAt<[1, 2, 3, 4, 5], 2, 2, ['a', 'b']> // [[1, 2, 'a', 'b', 5], [3, 4]]
  *
  * // out of bound resets to boundary
  * SplitAt<[1, 2, 3, 4, 5], 6> // [[1, 2, 3, 4, 5], []]
  * SplitAt<[1, 2, 3, 4, 5], -6> // [[], [1, 2, 3, 4, 5]]
  * ```
  */
-export type SplitAt<A extends unknown[], Index extends number> = ArrayType<
+export type SplitAt<
+	A extends readonly unknown[],
+	Index extends number,
+	DeleteCount extends number | never = never,
+	Insert extends readonly unknown[] | never = never
+> = ArrayType<
 	A,
 	[A, A],
-	ArraySplitAtDevice<A, [], IndexAt<A, Index>>
+	SplitAt._<A, [], [], IndexAt._<A, Index>, DeleteCount, Insert>
 >
 
-/**
- * Splits an array into two at the specified `Index`.
- * The device does not work on negative index nor out of bound index.
- */
-export type ArraySplitAtDevice<
-	A extends unknown[],
-	B extends unknown[],
-	Index extends number
-> = Index extends B['length']
-	? [B, A]
-	: A extends [infer Head, ...infer Tail]
-	? ArraySplitAtDevice<Tail, [...B, Head], Index>
-	: never
+export namespace SplitAt {
+	export type _<
+		A extends readonly unknown[],
+		B extends readonly unknown[],
+		C extends readonly unknown[],
+		Index extends number,
+		DeleteCount,
+		Insert extends readonly unknown[],
+	> = 0 extends A['length']
+		? IsTuple<Insert, [[...Insert, ...B], C], [B, C]>
+		: (Index extends B['length']
+			? NeverType<
+				DeleteCount,
+				[B, A],
+				_D<A, B, C, DeleteCount, Insert>>
+			: (A extends readonly [infer Head, ...infer Tail]
+				? _<Tail, [...B, Head], [], Index, DeleteCount, Insert>
+				: 'unexpected: A does not extends [Head, ...Tail]'))
+
+	export type _D<
+		A extends readonly unknown[],
+		B extends readonly unknown[],
+		C extends readonly unknown[],
+		DeleteCount,
+		Insert extends readonly unknown[],
+	> = DeleteCount extends C['length']
+		? IsTuple<Insert, [[...B, ...Insert, ...A], C], [[...B, ...A], C]>
+		: (A extends readonly [infer Head, ...infer Tail]
+			? _D<Tail, B, [...C, Head], DeleteCount, Insert>
+			: IsTuple<Insert, [[...Insert, ...B], C], [B, C]>
+		)
+
+}
+

package/ts/array/array_plus.ts

@@ -3,12 +3,14 @@ export type { Entries } from './array.entries.js'
 export type { FindLast } from './array.find_last.js'
 export type { Reverse } from './array.reverse.js'
 export type { Some } from './array.some.js'
-export type { IndexAt, IsIndexOutOfBound } from './array_index.js'
 export type { CommonPropKeys } from './array_plus.common_prop_keys.js'
 export type { Concat } from './array_plus.concat.js'
 export type { DropMatch } from './array_plus.drop_match.js'
 export type { ElementMatch } from './array_plus.element_match.js'
 export type { Filter } from './array_plus.filter.js'
 export type { Find } from './array_plus.find.js'
+export type { IndexAt } from './array_plus.index_at.js'
+export type { IsIndexOutOfBound } from './array_plus.is_index_out_of_bound.js'
+export type { IsReadonly } from './array_plus.is_readonly.js'
 export type { PadStart } from './array_plus.pad_start.js'
 export type { SplitAt } from './array_plus.split_at.js'

package/ts/array/array_type.ts

@@ -18,7 +18,11 @@ import type { StrictNumberType } from '../number/strict_number_type.js'
 export type ArrayType<T, Then = T, Else = never> = IsNever<
 	T,
 	Else,
-	[any[]] extends [T] ? ([T] extends [any[]] ? StrictNumberType<T['length'], Then, Else> : Else) : Else
+	[never[]] extends [T]
+	? ([T] extends [readonly any[]]
+		? StrictNumberType<T['length'], Then, Else>
+		: Else)
+	: Else
 >
 
 /**

package/ts/array/filter.ts

@@ -12,7 +12,7 @@ import type { Filter as FilterArray } from './array_plus.filter.js'
  * type R = Filter<Array<string | undefined>, string> // string[]
  * ```
  */
-export type Filter<A extends unknown[], Criteria> = number extends A['length']
+export type Filter<A extends readonly unknown[], Criteria> = number extends A['length']
 	? FilterArray<A, Criteria>
 	: FilterTuple<A, Criteria>
 
@@ -29,4 +29,4 @@ export type Filter<A extends unknown[], Criteria> = number extends A['length']
  * type R = KeepMatch<Array<string|undefined>, string> // string[]
  * ```
  */
-export type KeepMatch<A extends unknown[], Criteria> = Filter<A, Criteria>
+export type KeepMatch<A extends readonly unknown[], Criteria> = Filter<A, Criteria>

package/ts/array/find_first.ts

@@ -31,26 +31,26 @@ import type { Find as ArrayFind } from './array_plus.find.js'
  * With widen match, a narrowed type will match its widen type.
  * e.g. matching `1` against `number` yields `1 | undefined`
  *
- * The widen behavior can be customized by `Options['caseWiden']`
+ * The widen behavior can be customized by `Options['$widen']`
  *
  * @typeParam Options['caseEmptyTuple'] return type when `A` is an empty tuple.
  * Default to `never`.
  *
- * @typeParam Options['caseNever'] return type when `A` is `never`. Default to `never`.
+ * @typeParam Options['$never'] return type when `A` is `never`. Default to `never`.
  *
- * @typeParam Options['caseNoMatch'] Return value when `T` does not match `Criteria`.
+ * @typeParam Options['$noMatch'] Return value when `T` does not match `Criteria`.
  * Default to `never`.
  *
- * @typeParam Options['caseWiden'] return type when `T` in `A` is a widen type of `Criteria`.
+ * @typeParam Options['$widen'] return type when `T` in `A` is a widen type of `Criteria`.
  * Default to `Criteria | undefined`.
  * Set it to `never` for a more type-centric behavior
  *
- * @typeParam Options['caseUnionMiss'] Return value when a branch of the union `T` does not match `Criteria`.
+ * @typeParam Options['$unionMiss'] Return value when a branch of the union `T` does not match `Criteria`.
  * Default to `undefined`.
  * Since it is a union, the result will be join to the matched branch as union.
  */
 export type FindFirst<
-	A extends unknown[],
+	A extends readonly unknown[],
 	Criteria, Options extends FindFirst.Options = FindFirst.DefaultOptions<Criteria>
 > = TupleType<
 	A,

package/ts/array/head.ts

@@ -14,18 +14,18 @@ import type { NeverType } from '../never/never_type.js'
  * type R = Head<[]> // never
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  *
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
  * Default to `never`.
  */
 export type Head<
-	T extends unknown[],
+	T extends readonly unknown[],
 	Options extends Head.Options = Head.DefaultOptions
 > = NeverType<
 	T,
-	Options['caseNever'],
+	Options['$never'],
 	T['length'] extends 0 ? Options['caseEmptyTuple'] : T[0]
 >
 

package/ts/array/intersect_of_props.ts

@@ -6,7 +6,7 @@ import type { Tail } from '../tuple/tail.js'
  *
  * Gets the intersect of properties of the elements in `A`.
  */
-export type IntersectOfProps<A extends Record<any, unknown>[], P extends KeyTypes> = number extends A['length']
+export type IntersectOfProps<A extends readonly  Record<any, unknown>[], P extends KeyTypes> = number extends A['length']
 	? A[0][P]
 	: A['length'] extends 0
 	? never

package/ts/array/last.ts

@@ -13,18 +13,20 @@ import type { NeverType } from '../never/never_type.js'
  * type R = Last<[]> // never
  * ```
  *
- * @typeParam Options['caseNever'] Return type when `T` is `never`.
+ * @typeParam Options['$never'] Return type when `T` is `never`.
  * Default to `never`.
  *
  * @typeParam Options['caseEmptyTuple'] Return type when `T` is `[]`.
  * Default to `never`.
  */
 export type Last<
-	T extends unknown[],
+	T extends readonly unknown[],
 	Options extends Last.Options = Last.DefaultOptions
 > = NeverType<T,
-	Options['caseNever'],
-	T['length'] extends 0 ? Options['caseEmptyTuple'] : T extends [...unknown[], infer R] ? R : T[0]
+	Options['$never'],
+	T['length'] extends 0
+	? Options['caseEmptyTuple']
+	: T extends readonly [...unknown[], infer R] ? R : T[0]
 >
 
 export namespace Last {

package/ts/array/loose_array_type.ts

@@ -0,0 +1,69 @@
+import type { IsAnyOrNever } from '../mix_types/any_or_never_type.js'
+
+/**
+ * 🌪️ *filter*
+ * 🚧 *temporary*
+ *
+ * Filter `T` to ensure it is an array or tuple.
+ *
+ * This is a temporary type before `ArrayType` is adjusted to loose check in the next version.
+ *
+ * @example
+ * ```ts
+ * type R = LooseArrayType<number[]> // number[]
+ * type R = LooseArrayType<[1]> // [1]
+ * type R = LooseArrayType<number[] | 1> // number[]
+ * type R = LooseArrayType<number[] & 1> // number[]s
+ *
+ * type R = LooseArrayType<string> // never
+ * ```
+ */export type LooseArrayType<T, Then = T, Else = never> = IsAnyOrNever<
+	T,
+	Else,
+	T extends readonly any[] ? Then : Else
+>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is an array or tuple.
+ *
+ * @example
+ * ```ts
+ * type R = IsLooseArray<number[]> // true
+ * type R = IsLooseArray<[1]> // true
+ *
+ * type R = IsLooseArray<number> // false
+ * ```
+ */
+export type IsLooseArray<T, Then = true, Else = false> = LooseArrayType<T, Then, Else>
+
+/**
+ * 🌪️ *filter*
+ *
+ * Filter `T` to ensure it is not an array nor tuple.
+ *
+ * @example
+ * ```ts
+ * type R = NotLooseArrayType<number[]> // never
+ * type R = NotLooseArrayType<[1]> // never
+ *
+ * type R = NotLooseArrayType<number> // number
+ * ```
+ */
+export type NotLooseArrayType<T, Then = T, Else = never> = LooseArrayType<T, Else, Then>
+
+/**
+ * 🎭 *validate*
+ *
+ * Validate that `T` is not an array nor tuple.
+ *
+ * @example
+ * ```ts
+ * type R = IsNotLooseArray<number[]> // false
+ * type R = IsNotLooseArray<[1]> // false
+ *
+ * type R = IsNotLooseArray<number> // true
+ * ```
+ */
+export type IsNotLooseArray<T, Then = true, Else = false> = LooseArrayType<T, Else, Then>

package/ts/array/pad_start.ts

@@ -26,7 +26,7 @@ import type { PadStart as PadStartArray } from './array_plus.pad_start.js'
  * ```
  */
 export type PadStart<
-	A extends unknown[],
+	A extends readonly unknown[],
 	MaxLength extends number,
 	PadWith = unknown
 > = number extends A['length']

package/ts/array/readme.md

@@ -14,7 +14,7 @@ The `ArrayType<T>` and friends are used to check if a type is exactly `Array<T>`
 They are strict type checks, meaning they match only the type `Array<T>`,
 and not [tuple], [union], or intersection types.
 
-### [ArrayType](./array_type.ts#18)
+### [ArrayType](./array_type.ts#l18)
 
 `ArrayType<T, Then = T, Else = never>`
 
@@ -32,7 +32,7 @@ type R = ArrayType<number[] | 1> // never
 type R = ArrayType<number[] & { a: 1 }> // never
 ```
 
-### [IsArray](./array_type.ts#37)
+### [IsArray](./array_type.ts#l41)
 
 `IsArray<T, Then = true, Else = false>`
 
@@ -49,7 +49,7 @@ type R = IsArray<number> // false
 type R = IsArray<[1]> // false
 ```
 
-### [NotArrayType](./array_type.ts#54)
+### [NotArrayType](./array_type.ts#l58)
 
 `NotArrayType<T, Then = T, Else = never>`
 
@@ -66,7 +66,7 @@ type R = NotArrayType<number> // number
 type R = NotArrayType<[1]> // [1]
 ```
 
-### [IsNotArrayType](./array_type.ts#71)
+### [IsNotArrayType](./array_type.ts#l75)
 
 `IsNotArrayType<T, Then = true, Else = false>`
 
@@ -113,7 +113,7 @@ If the `N` is out of bound,
 or `N` is not a valid index,
 `ArrayPlus.At` will return the `Fail` case, which defaults to `never`.
 
-## [`Concat`](./array.concat.ts#L12)
+## [`Concat`](./array_plus.concat.ts#l15)
 
 `Concat<A, B>`
 
@@ -129,7 +129,7 @@ You are encouraged to use `[...A, ...B]` directly.
 
 ## [`FindFirst`](./find_first.ts#l52)
 
-`FindFirst<A, Criteria, Options = { widen, caseEmptyTuple, caseNever, caseNoMatch, caseWiden, caseUnionMiss }>`
+`FindFirst<A, Criteria, Options = { widen, caseEmptyTuple, $never, $noMatch, $widen, $unionMiss }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -154,14 +154,14 @@ type R = FindFirst<string[], number> // never
 
 // customization
 type R = FindFirst<[number], 1, { widen: false }> // never
-type R = FindFirst<[number], 1, { caseWiden: never }> // never
+type R = FindFirst<[number], 1, { $widen: never }> // never
 type R = FindFirst<[], 1, { caseEmptyTuple: 2 }> // 2
-type R = FindFirst<never, 1, { caseNever: 2 }> // 2
-type R = FindFirst<[string], number, { caseNotMatch: 2 }> // 2
-type R = FindFirst<[string | number], number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = FindFirst<never, 1, { $never: 2 }> // 2
+type R = FindFirst<[string], number, { $notMatch: 2 }> // 2
+type R = FindFirst<[string | number], number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
-## [`FindLast`](./array.find_last.ts)
+## [`FindLast`](./array.find_last.tsl19)
 
 ## [`Some`](./array.some.ts)
 
@@ -198,7 +198,7 @@ type R = KeepMatch<Array<string | undefined>, string> // string[]
 
 ## [`Head`](./head.ts#l23)
 
-`Head<T, Options = { caseNever, caseEmptyTuple }>`
+`Head<T, Options = { $never, caseEmptyTuple }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -210,11 +210,11 @@ import type { Head } from 'type-plus'
 
 type R = Head<[1, 2, 3]> // 1
 type R = Head<string[]> // string
-type R = Head<never> // caseNever: never
+type R = Head<never> // $never: never
 type R = Head<[]> // caseEmptyTuple: never
 
 // customization
-type R = Head<never, { caseNever: 1 }> // 1
+type R = Head<never, { $never: 1 }> // 1
 type R = Head<[], { caseEmptyTuple: undefined }> // undefined
 ```
 
@@ -224,7 +224,7 @@ type R = Head<[], { caseEmptyTuple: undefined }> // undefined
 
 ## [`Last`](./last.ts#l23)
 
-`Last<T, Options = { caseNever, caseEmptyTuple }>`
+`Last<T, Options = { $never, caseEmptyTuple }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -236,11 +236,11 @@ import type { Last } from 'type-plus'
 
 type R = Last<[1, 2, 3]> // 3
 type R = Last<string[]> // string
-type R = Last<never> // caseNever: never
+type R = Last<never> // $never: never
 type R = Last<[]> // caseEmptyTuple: never
 
 // customization
-type R = Last<never, { caseNever: 1 }> // 1
+type R = Last<never, { $never: 1 }> // 1
 type R = Last<[], { caseEmptyTuple: undefined }> // undefined
 ```
 
@@ -273,9 +273,9 @@ please check [`TuplePlus`](../tuple/readme.md#TuplePlus).
 
 Alias of [At](#at).
 
-## [ArrayPlus.CommonPropKeys](./array_plus.common_prop_keys.ts#l21)
+### [ArrayPlus.CommonPropKeys](./array_plus.common_prop_keys.ts#l21)
 
-`ArrayPlus.CommonPropKeys<T extends Record[], Options = { caseNever }>`
+`ArrayPlus.CommonPropKeys<T extends Record[], Options = { $never }>`
 
 ⚗️ *transform*
 🔢 *customizable*
@@ -289,7 +289,7 @@ type R = ArrayPlus.CommonPropKeys<Array<{ a: 1 }>> // 'a'
 type R = ArrayPlus.CommonPropKeys<Array<{ a: 1, b: 1 } | { a: 1, c: 1 }>> // 'a'
 
 // customization
-type R = ArrayPlus.CommonPropKeys<never, { caseNever: 1 }> // 1
+type R = ArrayPlus.CommonPropKeys<never, { $never: 1 }> // 1
 ```
 
 ### [`ArrayPlus.Concat`](./array.concat.ts#l12)
@@ -300,7 +300,7 @@ Alias of [Concat](#concat).
 
 ### [`ArrayPlus.ElementMatch`](./array_plus.element_match.ts#l30)
 
-`ArrayPlus.ElementMatch<T, Criteria, Options = { widen, caseNotMatch, caseWiden, caseUnionNotMatch }>`
+`ArrayPlus.ElementMatch<T, Criteria, Options = { widen, $notMatch, $widen, $unionNotMatch }>`
 
 🌪️ *filter*
 🔢 *customizable*
@@ -317,10 +317,10 @@ type R = ArrayPlus.ElementMatch<number, 1> // widen: 1
 type R = ArrayPlus.ElementMatch<number | string, number> // unionNotMatch: number
 
 // customization
-type R = ArrayPlus.ElementMatch<number, string, { caseNotMatch: 1 }> // 1
+type R = ArrayPlus.ElementMatch<number, string, { $notMatch: 1 }> // 1
 type R = ArrayPlus.ElementMatch<number, 1, { widen: false }> // never
-type R = ArrayPlus.ElementMatch<number, 1, { caseWiden: never }> // never
-type R = ArrayPlus.ElementMatch<number | string, number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = ArrayPlus.ElementMatch<number, 1, { $widen: never }> // never
+type R = ArrayPlus.ElementMatch<number | string, number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
 ### [`ArrayPlus.Entries`](./array.entries.ts#L14)
@@ -337,9 +337,26 @@ type R = ArrayPlus.Entries<Array<string | number>> // Array<[number, string | nu
 type R = ArrayPlus.Entries<[1, 2, 3]> // [[0, 1], [1, 2], [2, 3]]
 ```
 
+### [`ArrayPlus.Filter`](./array_plus.filter.ts#l11)
+
+`ArrayPlus.Filter<A, Criteria, Options = { $notArray }>`
+
+⚗️ *transform*
+🔢 *customizable*
+
+Filter the array `A`, keeping entries satisfying `Criteria`.
+
+```ts
+type R = Filter<Array<string | undefined>, string> // string[]
+
+// customization
+type R = Filter<never, string, { caseNever: 1 }> // 1
+type R = Filter<['x'], string, { $notArray: 1 }> // 1
+```
+
 ### [`ArrayPlus.Find`](./array_plus.find.ts#l49)
 
-`ArrayPlus.Find<A, Criteria, Options { widen, caseNever, caseNotMatch, caseTuple, caseWiden, caseUnionNotMatch }>`
+`ArrayPlus.Find<A, Criteria, Options { widen, $never, $notMatch, $tuple, $widen, $unionNotMatch }>`
 
 🦴 *utilities*
 🔢 *customizable*
@@ -359,11 +376,11 @@ type R = ArrayPlus.Find<string[], number> // never
 
 // customization
 type R = ArrayPlus.Find<number[], 1, { widen: false }> // never
-type R = ArrayPlus.Find<number[], 1, { caseWiden: never }> // never
-type R = ArrayPlus.Find<never, 1, { caseNever: 2 }> // 2
-type R = ArrayPlus.Find<string[], number, { caseNotMatch: 2 }> // 2
-type R = ArrayPlus.Find<[], 1, { caseTuple: 2 }> // 2
-type R = ArrayPlus.Find<Array<string | number>, number, { caseUnionNotMatch: undefined }> // number | undefined
+type R = ArrayPlus.Find<number[], 1, { $widen: never }> // never
+type R = ArrayPlus.Find<never, 1, { $never: 2 }> // 2
+type R = ArrayPlus.Find<string[], number, { $notMatch: 2 }> // 2
+type R = ArrayPlus.Find<[], 1, { $tuple: 2 }> // 2
+type R = ArrayPlus.Find<Array<string | number>, number, { $unionNotMatch: undefined }> // number | undefined
 ```
 
 ### [`ArrayPlus.FindLast`](./array.find_last.ts#L17)
@@ -382,7 +399,60 @@ ArrayPlus.FindLast<Array<1 | 2 | 'x'>, number> // 1 | 2 | undefined
 ArrayPlus.FindLast<[true, 123, 'x', 321], number> // 321
 ```
 
-### [`ArrayPlus.Reverse`](./array.reverse.ts#L14)
+### [`ArrayPlus.IndexAt](./array_plus.index_at.ts#l25)
+
+`ArrayPlus.IndexAt<A, Index>`
+
+🦴 *utilities*
+
+Gets the normalized index to access the element of an array or tuple.
+
+```ts
+type R = IndexAt<['a', 'b', 'c'], 2> // 2
+type R = IndexAt<['a', 'b', 'c'], -2> // 1
+
+type R = IndexAt<['a', 'b', 'c'], 3> // never
+type R = IndexAt<['a', 'b', 'c'], -4> // never
+```
+
+### [`ArrayPlus.IsIndexOutOfBound](./array_plus.is_index_out_of_bound.ts#l18)
+
+🎭 *validate*
+
+Is `N` an out of bound index of `A`.
+
+```ts
+type R = IsIndexOutOfBound<[1], 0> // false
+type R = IsIndexOutOfBound<[1], -1> // false
+
+type R = IsIndexOutOfBound<[1], 1> // true
+type R = IsIndexOutOfBound<[1], -2> // true
+```
+
+### [`ArrayPlus.IsReadonly](./array_plus.is_readonly.ts#l19)
+
+`ArrayPlus.IsReadonly<A, Options = { $then, $else, $never, $notArray }>`
+
+🎭 *validate*
+🔢 *customizable*
+
+Checks if `A` is a readonly array or tuple.
+
+```ts
+type R = IsReadonly<readonly string[]> // true
+type R = IsReadonly<readonly [1, 2, 3, 4, 5]> // true
+
+type R = IsReadonly<[1, 2, 3, 4, 5]> // false
+type R = IsReadonly<readonly string[] | number> // boolean
+
+// customization
+type R = IsReadonly<readonly string[], { $then: 1 }> // 1
+type R = IsReadonly<string[], { $else: 1 }> // 1
+type R = IsReadonly<number, { $notArray: 1 }> // 1
+type R = IsReadonly<never, { $never: 1 }> // 1
+```
+
+### [`ArrayPlus.Reverse`](./array.reverse.ts#l14)
 
 > `ArrayPlus.Reverse<A>`
 
@@ -394,12 +464,28 @@ ArrayPlus.Reverse<[1, 2, 3]> // [3, 2, 1]
 
 ### [`ArrayPlus.SplitAt`](./array_plus.split_at.ts#L22)
 
-> `ArrayPlus.SplitAt<A, Index>`
+`ArrayPlus.SplitAt<A, Index>`
+
+⚗️ *transform*
+
+Splits array or tuple `A` into two at the specified `Index`.
+
+If the `Index` is out of bounds,
+it will set to the boundary value.
 
-Splits the array or tuple at `Index`.
+It is the type level `splice()`.
 
 ```ts
-ArrayPlus.SplitAt<[1, 2, 3], 1> // [[1, 2], [3]]
+SplitAt<[1, 2, 3, 4, 5], 2> // [[1, 2], [3, 4, 5]]
+SplitAt<[1, 2, 3, 4, 5], -3> // [[1, 2], [3, 4, 5]]
+
+SplitAt<[1, 2, 3, 4, 5], 2, 2> // [[1, 2, 5], [3, 4]]
+
+SplitAt<[1, 2, 3, 4, 5], 2, 2, ['a', 'b']> // [[1, 2, 'a', 'b', 5], [3, 4]]
+
+// out of bound resets to boundary
+SplitAt<[1, 2, 3, 4, 5], 6> // [[1, 2, 3, 4, 5], []]
+SplitAt<[1, 2, 3, 4, 5], -6> // [[], [1, 2, 3, 4, 5]]
 ```
 
 ### [`ArrayPlus.Some`](./array.some.ts#L23)
@@ -440,6 +526,10 @@ while some common ones are exposed at top-level.
 
 Here are the list of array methods and their corresponding type-level functions, if available.
 
+✅ means it is implemented.
+✴️ means it is implemented with reduced functionality
+🧬 means there is a built-in mechanism or type for it.
+
 - ✅ `at`: [`ArrayPlus.At`](#arrayplusat)
 - ✅ `concat`: [`Concat` | `ArrayPlus.Concat`](#arrayplusconcat) (`[...A, ...B]`)
 - 🚧 `copyWithin`:  `CopyWithin<A, Target, Start, End>`
@@ -464,7 +554,7 @@ Here are the list of array methods and their corresponding type-level functions,
 - 🚧 `slice`:
 - ✴️ `some`: [`Some` | `ArrayPlus.Some`](#arrayplussome)
 - 🚧 `sort`:
-- 🚧 `splice`:
+- ✴️ `splice`: [`ArrayPlus.SplitAt`](#arrayplussplitat)
 - 🧬 `unshift`: `[T, ...A]`
 - 🧬 `values`: `keyof A`