手写常见的类型体操：DeepPartial、DeepReadonly、UnionToIntersection

// 不应该被递归展开的类型
type Builtin = Date | RegExp | Map<unknown, unknown> | Set<unknown> | ((...args: any[]) => unknown)

type DeepPartial<T> = T extends Builtin
  ? T
  : T extends object
    ? { [K in keyof T]?: DeepPartial<T[K]> }
    : T

type DeepReadonly<T> = T extends Builtin
  ? T
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T

interface Config {
  db: { host: string; port: number }
  tags: string[]
  createdAt: Date
  onReady: () => void
}

const patch: DeepPartial<Config> = { db: { port: 3307 } } // 只改深层的一个字段

declare const config: DeepReadonly<Config>
// @ts-expect-error 深层属性也是只读的
config.db.port = 1
// @ts-expect-error tags 变成了 readonly string[]，没有 push
config.tags.push('x')
config.createdAt.getTime() // Date 保持原样，方法可以正常调用
config.onReady() // 函数保持原样

type UnionToIntersection<U> =
  (U extends unknown ? (arg: U) => void : never) extends (arg: infer I) => void ? I : never

type A = UnionToIntersection<{ a: 1 } | { b: 2 }> // { a: 1 } & { b: 2 }

1. U extends unknown ? (arg: U) => void : never
   U 是裸类型参数，分发：((arg: { a: 1 }) => void) | ((arg: { b: 2 }) => void)

2. ... extends (arg: infer I) => void
   外层的 extends 左边不是裸类型参数，不分发，整个联合一起匹配
   I 在两个函数的参数位置各有一个候选：{ a: 1 } 和 { b: 2 }

3. 参数是逆变位置，多个候选取交叉：I = { a: 1 } & { b: 2 }

// 判断两个类型是否完全相同
type IsEqual<A, B> =
  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false

// 互相 extends 的写法分不清 any 和只读修饰符
type NaiveEqual<A, B> = [A] extends [B] ? ([B] extends [A] ? true : false) : false

type E1 = NaiveEqual<any, 1> // true ❌
type E2 = IsEqual<any, 1> // false ✅
type E3 = NaiveEqual<{ a: 1 }, { readonly a: 1 }> // true ❌
type E4 = IsEqual<{ a: 1 }, { readonly a: 1 }> // false ✅

// 元组转联合：直接用 number 索引
type TupleToUnion<T extends readonly unknown[]> = T[number]
type U = TupleToUnion<['a', 1, true]> // 'a' | 1 | true