TypeScript 2.8で追加予定のConditional型とinfer prefixが開発版でリリースされたので型レベル関数と念願のRequired/DeepRequired型を作って型レベルプログラミングを可能にする。
型レベル関数
Conditional型はUnion型を展開するためEq<false, boolean>の結果はその非決定性からbooleanとなる。決定的な結果を返す関数はboolean型にのみ用意しておりDEq<false, boolean>はundefinedとなる。
type Falsy = undefined | false | 0 | '' | null | void;
type Function = (...args: any[]) => any;
type Class = new (...args: any[]) => any;
export type Not<T extends boolean> =
T extends true ? false :
T extends false ? true :
never;
export type And<T, U> = T extends Falsy ? T : U;
export type Or<T, U> = T extends Falsy ? U : T;
export type Eq<T, U> = T extends U ? U extends T ? true : false : false;
export type If<S, T, U> = S extends Falsy ? U : T;
export type Case<T extends keyof U, U extends {}> = U[T];
export type DEq<T extends valueof<NondeterminateTypeMap>, U extends valueof<NondeterminateTypeMap>> =
Determine<T> extends undefined ? undefined :
Determine<U> extends undefined ? undefined :
Eq<T, U>;
type Determine<T extends valueof<NondeterminateTypeMap>> =
valueof<NondeterminateTypeMap> extends T ? undefined :
T;
interface NondeterminateTypeMap {
boolean: boolean;
}
export type keyof<T, V = any> = { [P in keyof T]: If<Eq<T[P], V>, P, never>; }[keyof T];
export type valueof<T, K = string> = { [P in keyof T]: P extends K ? T[P] : never; }[keyof T];
describe('Eq', () => {
it('', () => {
assert((): true => true as Eq<true, true>);
assert((): false => true as Eq<true, false>);
assert((): false => true as Eq<false, true>);
assert((): true => true as Eq<false, false>);
assert((): Eq<true, boolean> => true as boolean);
assert((): Eq<false, boolean> => true as boolean);
assert((): Eq<boolean, true> => true as boolean);
assert((): Eq<boolean, false> => true as boolean);
assert((): Eq<boolean, boolean> => true as boolean);
assert((): true => true as Eq<0, 0>);
assert((): false => true as Eq<0, number>);
assert((): true => true as Eq<number, number>);
assert((): true => true as Eq<undefined, undefined>);
assert((): false => true as Eq<void, undefined>);
assert((): false => true as Eq<void, null>);
assert((): false => true as Eq<void, undefined | null>);
assert((): true => true as Eq<void, void>);
});
});
describe('If', () => {
it('', () => {
assert((): 1 => 0 as If<true | 1, 1, 0>);
assert((): 0 => 0 as If<false | 0, 1, 0>);
});
});
describe('Case', () => {
it('', () => {
assert((): 1 => 0 as Case<'0', [1]>);
assert((): 1 => 0 as Case<'0', { 0: 1 }>);
assert((): number => 0 as Case<'1', { 0: 1, [otherwise: string]: number }>);
});
});
describe('DEq', () => {
it('', () => {
assert((): true => true as DEq<true, true>);
assert((): false => true as DEq<true, false>);
assert((): false => true as DEq<false, true>);
assert((): true => true as DEq<false, false>);
assert((): undefined => undefined as DEq<true, boolean>);
assert((): undefined => undefined as DEq<false, boolean>);
assert((): undefined => undefined as DEq<boolean, true>);
assert((): undefined => undefined as DEq<boolean, false>);
assert((): undefined => undefined as DEq<boolean, boolean>);
});
});
Requiredなど
Deep系は除外するオブジェクトを指定できるので必須と任意を組み合わせたりDOM要素などの組み込みオブジェクトを持つオブジェクトにも使用できる。
export type Partial<T> =
T extends object
? { [P in keyof T]?: T[P]; }
: T;
export type DeepPartial<T, U extends object | undefined = undefined> =
T extends object
? { [P in keyof T]?: NonNullable<T[P]> extends NonNullable<U | Function | Class> ? T[P] : DeepPartial<T[P], U>; }
: T;
type Purify<T extends string> = { [P in T]: P; }[T];
export type Required<T> =
T extends object
? { [P in Purify<keyof T>]: NonNullable<T[P]>; }
: T;
export type DeepRequired<T, U extends object | undefined = undefined> =
T extends object
? { [P in Purify<keyof T>]: NonNullable<T[P]> extends NonNullable<U | Function | Class> ? NonNullable<T[P]> : DeepRequired<NonNullable<T[P]>, U>; }
: T;
export type Readonly<T> =
T extends object
? { readonly [P in keyof T]: T[P]; }
: T;
export type DeepReadonly<T, U extends object | undefined = undefined> =
T extends object
? { readonly [P in keyof T]: NonNullable<T[P]> extends NonNullable<U | Function | Class> ? T[P] : DeepReadonly<T[P], U>; }
: T;
describe('Partial', () => {
it('', () => {
type R = { a: number; b: { c: string; }; d: () => 0; e: new () => object };
type P = { a?: number; b?: { c: string; }; d?: () => 0; e?: new () => object };
assert((): P => ({}) as Partial<R>);
assert((): Partial<R> => ({}) as P);
assert((): P => ({}) as Partial<Required<R>>);
assert((): Partial<Required<R>> => ({}) as P);
});
});
describe('DeepPartial', () => {
it('', () => {
type R = { a: number; b: { c: string; d: () => 0; e: new () => object }; };
type P = { a?: number; b?: { c?: string; d?: () => 0; e?: new () => object }; };
assert((): P => ({}) as DeepPartial<R>);
assert((): DeepPartial<R> => ({}) as P);
assert((): P => ({}) as DeepPartial<R>);
assert((): DeepPartial<R> => ({}) as P);
assert((): Partial<R> => ({}) as DeepPartial<R, R['b']>);
assert((): DeepPartial<R, R['b']> => ({}) as Required<R>);
});
});
describe('Required', () => {
it('', () => {
type R = { a: number; b: { c?: string; }; d: () => 0; e: new () => object };
type P = { a?: number; b?: { c?: string; }; d?: () => 0; e?: new () => object };
assert((): R => ({}) as Required<P>);
assert((): Required<P> => ({}) as R);
assert((): R => ({}) as Required<Partial<R>>);
assert((): Required<Partial<R>> => ({}) as R);
});
});
describe('DeepRequired', () => {
it('', () => {
type R = { a: number; b: { c: string; d: () => 0; e: new () => object }; };
type P = { a?: number; b?: { c?: string; d?: () => 0; e?: new () => object }; };
assert((): R => ({}) as DeepRequired<P>);
assert((): DeepRequired<P> => ({}) as R);
assert((): R => ({}) as DeepRequired<DeepPartial<R>>);
assert((): DeepRequired<DeepPartial<R>> => ({}) as R);
assert((): Required<P> => ({}) as DeepRequired<P, P['b']>);
assert((): DeepRequired<P, P['b']> => ({}) as Required<P>);
});
});
describe('Readonly', () => {
it('', () => {
type I = { readonly a?: number; readonly b: { c: string; }; readonly d: () => 0; readonly e: new () => object };
type M = { a?: number; b: { c: string; }; d: () => 0; e: new () => object };
assert((): I => ({}) as Readonly<M>);
assert((): Readonly<M> => ({}) as I);
});
});
describe('DeepReadonly', () => {
it('', () => {
type I = { readonly a?: number; readonly b: { readonly c: string; readonly d: () => 0; readonly e: new () => object }; };
type M = { a?: number; b: { c: string; d: () => 0; e: new () => object }; };
assert((): I => ({}) as DeepReadonly<M>);
assert((): DeepReadonly<M> => ({}) as I);
assert((): Readonly<M> => ({}) as DeepReadonly<M, M['b']>);
assert((): DeepReadonly<M, M['b']> => ({}) as Readonly<M>);
});
});
型レベルプログラミング
非決定性計算がはかどりそうな気がするがお題が浮かばなかった。
https://github.com/falsandtru/spica/blob/master/src/lib/type.ts
https://github.com/falsandtru/spica/blob/master/src/lib/type.test.ts