Type Utilities & Inference

🔧 Type Utilities & Inference

📚 Built-In Utility Types

TypeScript provides a standard library of utility types for common transformations:

Copyinterface User {
  id: number;
  name: string;
  email: string;
  age: number;
}

// Partial — all properties optional
type PartialUser = Partial<User>;
// { id?: number; name?: string; email?: string; age?: number; }

// Required — all properties required
type RequiredUser = Required<PartialUser>;
// { id: number; name: string; email: string; age: number; }

// Readonly — all properties readonly
type ReadOnlyUser = Readonly<User>;
// { readonly id: number; readonly name: string; ... }

// Pick — select specific properties
type UserPreview = Pick<User, "name" | "email">;
// { name: string; email: string; }

// Omit — exclude specific properties
type UserWithoutPassword = Omit<User, "password">;
// { id: number; name: string; email: string; age: number; }

// Record — build object with specific keys
type UserRoles = Record<"admin" | "user" | "guest", User[]>;
// { admin: User[]; user: User[]; guest: User[]; }

🔍 Extract & Exclude: Filter Unions

Work with unions by keeping or removing types:

Copytype StringOrNumber = string | number | boolean;

// Extract — keep types assignable to U
type Strings = Extract<StringOrNumber, string>;
// string

// Exclude — remove types assignable to U
type NonStrings = Exclude<StringOrNumber, string>;
// number | boolean

// Practical: filter event types
type Events = "click" | "focus" | "blur" | "change";
type FocusEvents = Extract<Events, "focus" | "blur">;
// "focus" | "blur"

🔄 Extract Types From Functions

Infer function signatures to build related types:

Copyfunction getUser(id: number): { id: number; name: string } {
  return { id, name: "Alice" };
}

// ReturnType — extract return type
type UserReturn = ReturnType<typeof getUser>;
// { id: number; name: string }

// Parameters — extract parameter types
type GetUserParams = Parameters<typeof getUser>;
// [id: number]

// ConstructorParameters — for class constructors
class User {
  constructor(name: string, age: number) { }
}

type UserConstructorParams = ConstructorParameters<typeof User>;
// [name: string, age: number]

🎯 Type Predicates: Smart Narrowing

Custom type guards that narrow types intelligently:

Copyinterface Dog {
  bark(): void;
}

interface Cat {
  meow(): void;
}

// Type predicate: "value is Dog" tells TypeScript to narrow
function isDog(animal: Dog | Cat): animal is Dog {
  return typeof (animal as Dog).bark === "function";
}

const pet: Dog | Cat = getPet();

if (isDog(pet)) {
  pet.bark();  // ✅ TypeScript knows pet is Dog
} else {
  pet.meow();  // ✅ TypeScript knows pet is Cat
}

🔗 Composing Utility Types

Chain utilities to build complex transformations:

Copyinterface User {
  id: number;
  name: string;
  email: string;
  password: string;
}

// Exclude password, make all optional, make readonly
type SafeUserPreview = Readonly<Partial<Omit<User, "password">>>;

// Equivalent to:
// {
//   readonly id?: number;
//   readonly name?: string;
//   readonly email?: string;
// }

// Use it for API responses
const preview: SafeUserPreview = {
  name: "Alice",
  // email is optional, id is optional
};

🏗️ Real-World Pattern: Generic API Wrapper

Copyinterface Entity {
  id: number;
  createdAt: Date;
  updatedAt: Date;
}

interface ApiResponse<T extends Entity> {
  status: "success" | "error";
  data?: T;
  error?: string;
}

class Repository<T extends Entity> {
  // Create uses partial (no id, timestamps auto-generated)
  async create(data: Omit<T, "id" | "createdAt" | "updatedAt">): Promise<T> {
    // Simulate API call
    return {
      ...data,
      id: Math.random(),
      createdAt: new Date(),
      updatedAt: new Date()
    } as T;
  }

  // Update uses partial (update only what changed)
  async update(id: number, data: Partial<Omit<T, "id" | "createdAt">>): Promise<T> {
    // Update logic here
    return {} as T;
  }
}

// Usage with User type
interface User extends Entity {
  name: string;
  email: string;
}

const userRepo = new Repository<User>();

// Create requires name and email, NOT id/timestamps
await userRepo.create({ name: "Alice", email: "alice@example.com" });

// Update can be partial
await userRepo.update(1, { name: "Bob" });  // ✅ Only name

💻 Coding Challenges

🎯 What's Next

With type utilities mastered, we'll explore Error Handling & Validation — custom error types, runtime validation, and exhaustiveness checking for bullet-proof code.