泛型编程（下）

type Person = { id: number; name: string; age: number };

type Readonly<T> = {
  readonly [K in keyof T]: T[K];
};
type X1 = Readonly<Person>;
// {
//   readonly id: number;
//   readonly name: string;
//   readonly age: number;
// }

type Mutable<T> = {
  -readonly [K in keyof T]: T[K];
};
type X9 = Mutable<Readonly<Person>>;
// {
//   id: number;
//   name: string;
//   age: number;
// }

type Person = { id: number; name: string; age: number };

type Partial<T> = {
  [K in keyof T]?: T[K];
};
type X2 = Partial<Person>;
// {
//   id?: number;
//   name?: string;
//   age?: number;
// }

type Required<T> = {
  [K in keyof T]-?: T[K];
};
type X3 = Required<Person>;
// {
//   id: number;
//   name: string;
//   age: number;
// }

type Exclude<A, B> = A extends B ? never : A;
type X5 = Exclude<1 | 2 | 3, 1 | 2>; // 3

type Extract<A, B> = A extends B ? A : never;
type X6 = Extract<1 | 2 | 3, 2 | 4>; // 2

type X5 = 1 | 2 | 3 extends 1 | 2 ? never : A

type X5 = 
| 1 extends 1 | 2 ? never : 1 // never
| 2 extends 1 | 2 ? never : 2 // never
| 3 extends 1 | 2 ? never : 3 // 3

type X5 = never | never | 3 // 3

type Person = { id: number; name: string; age: number };

type Omit<T, Key extends keyof T> = Pick<T, Exclude<keyof T, Key>>;
// 或者
type Omit<T, Key> = {
  [K2 in keyof T as (K2 extends Key ? never : K2)]: T[K2];
};
type X7 = Omit<Person, 'name' | 'age'>; // { id: number }

type Pick<T, Key extends keyof T> = {
  [K2 in Key]: T[K2];
};
type X8 = Pick<Person, 'name' | 'age'>; // { name: string; age: number }

type Record<Key extends string | number | symbol, Value> = {
  [k in Key]: Value;
};

type X4 = Record<string, string>; // { [x: string]: string }

function f(a: number, b: number) {
  return 'a + b'
}

type F = ReturnType<typeof f> // string