TypeScript Types and Generics

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

# Use a type parameter for reusable function typing.

function first<T>(items: T[]): T | undefined {
  return items[0];
}

# Write array helpers that preserve element types.

interface ApiResponse<T> {
  data: T;
  error?: string;
}

# Parameterize a reusable interface.

function printLength<T extends { length: number }>(value: T) {
  console.log(value.length);
}

# Require a minimum shape for a type parameter.

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

# Accept only valid property names for a given object type.

type User = { id: number; name: string };
type UserKeys = keyof User; // "id" | "name"

# Get a union of property names from a type.

const config = {
  retries: 3,
  cache: true,
};

type Config = typeof config;

# Infer a type from an existing value.

type User = { profile: { email: string } };
type Email = User["profile"]["email"];

# Get a nested property type from another type.

type Method = "GET" | "POST";
type Route = "/users" | "/posts";
type Endpoint = `${Method} ${Route}`;

# Compose string literal types from smaller pieces.

type Flags<T> = {
  [K in keyof T]: boolean;
};

# Create a type by iterating over keys.

type IsString<T> = T extends string ? true : false;

# Choose a type based on another type relationship.

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

# Use `infer` inside a conditional type.

type Success = { kind: "success"; data: string };
type Failure = { kind: "error"; message: string };
type Result = Success | Failure;

# Model variant objects with a shared discriminant field.

type User = { id: number; name: string; email: string };
type UserPatch = Partial<User>;

# Make every property optional.

type User = { id?: number; name?: string };
type CompleteUser = Required<User>;

# Make all properties required.

type User = { id: number; name: string; email: string };
type PublicUser = Pick<User, "id" | "name">;

# Select a subset of properties.

type User = { id: number; passwordHash: string; email: string };
type SafeUser = Omit<User, "passwordHash">;

# Remove properties from a type.

type FeatureFlag = "billing" | "search";
const flags: Record<FeatureFlag, boolean> = {
  billing: true,
  search: false,
};

# Type objects whose keys all map to the same value type.

type Result = Awaited<Promise<Promise<string>>>; // string

# Unwrap the resolved type of a promise-like value.

function createUser() {
  return { id: 1, name: "Ada" };
}

type User = ReturnType<typeof createUser>;

# Extract a function’s return type.