types

AnyFn

export type AnyFn = (...args: any[]) => any;

Head

获取第一个类型

export type Head<T extends any[]> = T extends [any, ...any[]] ? T[0] : never;

Head<[number, string]>; // number

Tail

获取剩余类型

export type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : [];

Tail<[number, string, boolean]>; // [string, boolean]

Last

获取最后一个类型

export type Last<T extends any[]> = {
  0: Last<Tail<T>>;
  1: Head<T>;
}[HasTail<T> extends true ? 0 : 1];

Last<[string, number]>; // number

HasTail

是否还有剩余参数

export type HasTail<T extends any[]> = T extends [] | [any] ? false : true;

HasTail<[]>; // false
HasTail<[number]>; // false
HasTail<[number, string]>; // true

Length

export type Length<T extends any[]> = T["length"];

Prepend

元组顶部添加一个类型

export type Prepend<E, T extends any[]> = [E] extends [never] ? T : [E, ...T];

Prepend<number, [string, boolean]>; // [number, string, boolean]

Drop

丢弃元组前 N 个类型

export type Drop<N extends number, T extends any[], I extends any[] = []> = {
  0: Drop<N, Tail<T>, Prepend<any, I>>;
  1: T;
}[Length<I> extends N ? 1 : 0];

Drop<2, [0, 1, 2]>; // [2]

Cast

X 是 Y 的子集则校验类型为 X，否则使用 Y 类型校验

export type Cast<X, Y> = X extends Y ? X : Y;

Iterator

创建位于Index定义位置的迭代器，可选通过使用From从另一个迭代器的位置开始

export type Iterator<
  Index extends number = 0,
  From extends any[] = [],
  I extends any[] = []
> = {
  0: Iterator<Index, Next<From>, Next<I>>;
  1: From;
}[Pos<I> extends Index ? 1 : 0];

type iterator1 = Iterator<2>; // [any, any]
Iterator<1, iterator1>; // [any, any, any]

Pos

查询迭代器位置

export type Pos<I extends any[]> = Length<I>;

Pos<[0, 0]>; // 2
Post<Iterator<5>>; // 5

Next

迭代器+1

export type Next<I extends any[]> = Prepend<any, I>;

Next<Iterator<0>>; // [any]

Prev

迭代器-1

export type Prev<I extends any[]> = Tail<I>;

Prev<Iterator<2>>; // [any]

Append

追加元组条目

export type Append<E, T extends any[]> = Concat<T, E>;

type xs1 = [0, 1];
Append<2, xs1>; // [0, 1, 2]

Reverse

反转元组

export type Reverse<
  T extends any[],
  R extends any[] = [],
  I extends any[] = []
> = {
  0: Reverse<T, Prepend<T[Pos<I>], R>, Next<I>>;
  1: R;
}[Length<T> extends Pos<I> ? 1 : 0];

Reverse<[0, 1, 2]>; // [2, 1, 0]

Concat

export type Concat<T, U> = T extends any[]
  ? U extends any[]
    ? [...T, ...U]
    : [...T, U]
  : U extends any[]
  ? [T, ...U]
  : [T, U];

Concat<string, 0>; // [string, 0]
Concat<0, [1, 2]>; // [0, 1, 2]
Concat<[3, 4], 5>; // [3, 4, 5]