Utility types from scratch

The mapped-type family

You have used Partial, Required, and Readonly a hundred times — but could you write them from scratch? Once you can, you stop treating the standard library as a black box and start reaching into it when it doesn’t fit. Partial, Required, and Readonly are mapped types with a modifier; Pick and Record choose the key set:

type MyPartial<T>  = { [P in keyof T]?: T[P] };          // add ? to every key
type MyRequired<T> = { [P in keyof T]-?: T[P] };          // -? removes optionality
type MyReadonly<T> = { readonly [P in keyof T]: T[P] };   // add readonly
type MyPick<T, K extends keyof T> = { [P in K]: T[P] };   // map over a key subset
type MyRecord<K extends keyof any, V> = { [P in K]: V };  // build from keys + value

The modifier syntax is the whole story: ? and readonly add a modifier; -? and -readonly strip one. keyof any is string | number | symbol — the legal key space for Record.

The conditional family: infer the interesting part

ReturnType, Parameters, InstanceType, and Awaited all use infer to pull a piece out of a structural shape:

type MyReturnType<F> = F extends (...args: any) => infer R ? R : any;
type MyParameters<F> = F extends (...args: infer P) => any ? P : never;
type MyInstanceType<C> = C extends new (...args: any) => infer R ? R : any;

type R1 = MyReturnType<() => number>;          // ^? type R1 = number
type P1 = MyParameters<(a: string, b: number) => void>; // ^? type P1 = [a: string, b: number]

Awaited is the recursive one — it unwraps nested promises and .then-ables down to the final value:

type MyAwaited<T> =
  T extends null | undefined ? T :
  T extends object & { then(onfulfilled: infer F, ...args: any): any }
    ? F extends (value: infer V, ...args: any) => any ? MyAwaited<V> : never
    : T;

type A1 = MyAwaited<Promise<Promise<string>>>;
//   ^? type A1 = string   (recursion unwraps both layers)

Composing: DeepPartial and DeepReadonly

Recurse the mapped type into nested objects, with a conditional base case for non-objects:

type DeepReadonly<T> = T extends (infer E)[]
  ? ReadonlyArray<DeepReadonly<E>>
  : T extends object
    ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
    : T;

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

type Config = { db: { host: string; pool: { max: number } } };
type DC = DeepPartial<Config>;
//   ^? every level optional: { db?: { host?: string; pool?: { max?: number } } }

The base case is “not an object — return it unchanged”; the recursive case re-maps each property through the same deep transform.

The Omit trap — and DistributiveOmit

Here is the discriminated-union surprise from the Hook. Omit<T, K> = Pick<T, Exclude<keyof T, K>>. When T is a union, keyof T collapses to only the keys present in every member:

type Circle = { kind: "circle"; radius: number };
type Square = { kind: "square"; side: number };
type Shape = Circle | Square;

type Bad = Omit<Shape, "kind">;
//   ^? type Bad = {}   (keyof Shape is only "kind"; removing it leaves nothing)

// Force distribution so Omit runs per-member:
type DistributiveOmit<T, K extends keyof any> =
  T extends unknown ? Omit<T, K> : never;

type Good = DistributiveOmit<Shape, "kind">;
//   ^? type Good = { radius: number } | { side: number }

Omit is intentionally non-distributive — it operates on T as a whole, so keyof (Circle | Square) is just "kind" (the intersection of key sets). Wrapping it in a naked-parameter conditional (T extends unknown ? Omit<T, K> : never) forces distribution: now Omit runs once per variant and you get the per-variant result you expected. This single pattern is the most common reason people think Omit is broken on unions.