TypeScript Functional Programming

Quick Start

Core principles: Pure functions | Immutability | Composition | Higher-order functions | Declarative over imperative

Prefer: ? : over if | switch over if/else chains | map/filter/reduce over loops | const over let | Expressions over statements

Example

// ❌ Imperative
function processUsers(users: User[]): string[] {
  let result = [];
  for (let i = 0; i < users.length; i++) {
    if (users[i].age >= 18) {
      result.push(users[i].name.toUpperCase());
    }
  }
  return result;
}

// ✅ Functional
const processUsers = (users: User[]): string[] =>
  users
    .filter(user => user.age >= 18)
    .map(user => user.name.toUpperCase());

// ✅ Ternary over if
const getStatus = (age: number): string =>
  age >= 18 ? 'adult' : 'minor';

// ✅ Switch for multiple conditions
const getDiscount = (tier: Tier): number => {
  switch (tier) {
    case 'gold': return 0.2;
    case 'silver': return 0.1;
    case 'bronze': return 0.05;
    default: return 0;
  }
};

Reference Files

Check these before suggesting code:

• references/pure-functions.md – Pure function patterns and side effect handling
• references/array-methods.md – map, filter, reduce, and functional iteration
• references/composition.md – Function composition and piping patterns
• references/immutability.md – Immutable data structures and updates
• references/control-flow.md – Ternaries, switch, and functional conditionals

Notes

• Avoid mutations: Use spread operators and array methods
• No let unless absolutely necessary (prefer const)
• Functions should be small, single-purpose, composable
• Prefer function expressions over statements
• Use type inference when possible, explicit types when needed
• Early returns are acceptable for guard clauses
• Last verified: 2025-12-03