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