TypeScript Cheatsheet 03 — Generics

function identity<T>(x: T): T {
  return x;
}

identity(42);             // T inferred as number
identity<string>("hi");   // explicit

function pair<A, B>(a: A, b: B): [A, B] {
  return [a, b];
}

pair("hi", 42);           // [string, number]

function len<T extends { length: number }>(x: T): number {
  return x.length;
}

len("hi");                // ok
len([1, 2, 3]);           // ok
len(42);                  // ERROR: no length

function pluck<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key];
}

const u = { id: 1, name: "A" };
pluck(u, "id");           // number
pluck(u, "missing");      // ERROR

function box<T = string>(x: T): { value: T } {
  return { value: x };
}

box("hi");                // T = string
box<number>(42);

interface Result<T, E = Error> {
  ok: boolean;
  value?: T;
  error?: E;
}

type Pair<A, B = A> = [A, B];

class Stack<T> {
  private items: T[] = [];
  push(x: T) { this.items.push(x); }
  pop(): T | undefined { return this.items.pop(); }
}

const s = new Stack<number>();

type IsArray<T> = T extends any[] ? true : false;
type A = IsArray<number[]>;     // true
type B = IsArray<string>;       // false

type ReturnOf<T> = T extends (...args: any[]) => infer R ? R : never;

type R = ReturnOf<() => string>;   // string

// Unwrap promise
type Awaited2<T> = T extends Promise<infer U> ? U : T;

type ToArray<T> = T extends any ? T[] : never;
type X = ToArray<string | number>;   // string[] | number[]

type ToArray<T> = [T] extends [any] ? T[] : never;
type X = ToArray<string | number>;   // (string | number)[]

type Optional<T> = { [K in keyof T]?: T[K] };
type Readonly2<T> = { readonly [K in keyof T]: T[K] };
type Stringify<T> = { [K in keyof T]: string };

type Getters<T> = {
  [K in keyof T as `get${Capitalize<string & K>}`]: () => T[K];
};

type G = Getters<{ id: number; name: string }>;
// { getId: () => number; getName: () => string }

function getById<T extends { id: number } = { id: number }>(
  items: T[],
  id: number
): T | undefined {
  return items.find(x => x.id === id);
}

function create<T>(Ctor: new () => T): T {
  return new Ctor();
}

class Widget {}
const w = create(Widget);     // Widget

type Result<T> =
  | { ok: true; value: T }
  | { ok: false; error: string };

function unwrap<T>(r: Result<T>): T {
  if (r.ok) return r.value;
  throw new Error(r.error);
}

function call<T>(value: T, transformer: (x: NoInfer<T>) => T): T {
  return transformer(value);
}

call("hi", (x: string) => x.toUpperCase());
// T inferred from first arg, NOT the second

interface Functor<F> {
  map<A, B>(fa: F & A, f: (a: A) => B): F & B;
}

function List<T>({ items, render }: {
  items: T[];
  render: (item: T) => React.ReactNode;
}) {
  return <ul>{items.map((it, i) => <li key={i}>{render(it)}</li>)}</ul>;
}

<List items={[1, 2, 3]} render={(n) => n * 2} />

type Animal = { name: string };
type Dog = Animal & { bark(): void };

type Producer<out T> = () => T;       // covariant
type Consumer<in T> = (x: T) => void; // contravariant
type Bivariant<in out T> = ...;