DEV Community

Cover image for The Art of Beautiful Functions in TypeScript - Part 2
Tareq Hossain
Tareq Hossain

Posted on

The Art of Beautiful Functions in TypeScript - Part 2

Advanced Patterns for Elegant Code

4. Function Composition and Pipelines

Function composition is the art of combining simple functions to build more complex operations. TypeScript's type system makes this particularly powerful and safe.

The Pipe Function

type PipeFunction = {
  <A, B>(fn1: (arg: A) => B): (arg: A) => B;
  <A, B, C>(fn1: (arg: A) => B, fn2: (arg: B) => C): (arg: A) => C;
  <A, B, C, D>(fn1: (arg: A) => B, fn2: (arg: B) => C, fn3: (arg: C) => D): (arg: A) => D;
  // ... more overloads as needed
};

const pipe: PipeFunction = (...fns: Array<(arg: any) => any>) =>
  (value: any) => fns.reduce((acc, fn) => fn(acc), value);

// Usage example
const processUser = pipe(
  (user: RawUser) => validateUser(user),
  (user: ValidUser) => enrichUserData(user),
  (user: EnrichedUser) => formatUserProfile(user)
);
Enter fullscreen mode Exit fullscreen mode

Pipe functions are allow you to chain multiple functions together, where the output of one becomes the input of the next, while preserving type inference across each step.You may already seen them if you already use rxjs pipe function.

Currying for Reusability

const createFilter = <T>(predicate: (item: T) => boolean) =>
  (items: T[]) => items.filter(predicate);

const createMapper = <T, U>(transform: (item: T) => U) =>
  (items: T[]) => items.map(transform);

// Create reusable functions
const filterActive = createFilter((user: User) => user.isActive);
const mapToNames = createMapper((user: User) => user.name);

const getActiveUserNames = pipe(
  filterActive,
  mapToNames
);
Enter fullscreen mode Exit fullscreen mode

Here createFilter and createMapper both are higher-order factory functions designed to promote reusability in data processing.

The createFilter and createMapper functions are factory utilities that generate reusable array operations.

createFilter takes a predicate and returns a function that filters arrays based on that condition, while createMapper takes a transform function and returns a function that maps each array item to a new value.
Together, they enable clean, declarative data pipelines—letting you compose custom filtering and transformation logic (e.g., mapToNames(filterActive(users))) with excellent reusability and readability.

5. Type-Safe Error Handling

Moving beyond try-catch blocks to functional error handling patterns.

The Result Pattern

type Result<T, E = Error> = 
  | { success: true; data: T }
  | { success: false; error: E };

const Ok = <T>(data: T): Result<T, never> => ({ success: true, data });
const Err = <E>(error: E): Result<never, E> => ({ success: false, error });

// Utility functions for Result
const map = <T, U, E>(
  result: Result<T, E>,
  fn: (value: T) => U
): Result<U, E> => 
  result.success ? Ok(fn(result.data)) : result;

const chain = <T, U, E>(
  result: Result<T, E>,
  fn: (value: T) => Result<U, E>
): Result<U, E> => 
  result.success ? fn(result.data) : result;

// Example usage
const parseUser = (json: string): Result<User, string> => {
  try {
    const data = JSON.parse(json);
    return validateUser(data) ? Ok(data) : Err("Invalid user data");
  } catch {
    return Err("Invalid JSON");
  }
};

const processUserData = (json: string): Result<string, string> =>
  pipe(
    parseUser,
    result => map(result, enrichUserData),
    result => map(result, user => user.displayName)
  )(json);
Enter fullscreen mode Exit fullscreen mode

This code introduces a type-safe Result pattern inspired by functional programming, providing a clean alternative to try/catch error handling.
It wraps success and failure outcomes in explicit types—Ok for success and Err for failure—making it easier to handle errors predictably while keeping code readable and composable.

In detail, the Result type allows functions to return either a success value or an error without throwing exceptions. The helper functions map and chain enable safe transformations and chaining of operations only when the result is successful, skipping computation if an error occurs. In the example, parseUser safely parses and validates user data, while processUserData uses pipe to compose multiple transformations (enrichUserData, user.displayName) in a declarative, error-aware flow — ensuring that every step is type-checked and failure-proof.

Option Pattern for Nullable Values

type Option<T> = T | null | undefined;

const Some = <T>(value: T): T => value;
const None = null;

const mapOption = <T, U>(
  option: Option<T>,
  fn: (value: T) => U
): Option<U> => option ? fn(option) : None;

const chainOption = <T, U>(
  option: Option<T>,
  fn: (value: T) => Option<U>
): Option<U> => option ? fn(option) : None;

// Safe navigation without optional chaining
const getUserCity = (user: Option<User>): Option<string> =>
  chainOption(user, u => 
    chainOption(u.address, addr => addr.city)
  );
Enter fullscreen mode Exit fullscreen mode

6. Advanced Generic Patterns

Conditional Types for Function Overloading

type ApiResponse<T> = T extends string
  ? { message: T }
  : T extends number
  ? { count: T }
  : T extends object
  ? { data: T }
  : never;

function createResponse<T>(value: T): ApiResponse<T> {
  if (typeof value === 'string') {
    return { message: value } as ApiResponse<T>;
  }
  if (typeof value === 'number') {
    return { count: value } as ApiResponse<T>;
  }
  return { data: value } as ApiResponse<T>;
}

// Type-safe usage
const stringResponse = createResponse("Hello"); // { message: string }
const numberResponse = createResponse(42);      // { count: number }
const objectResponse = createResponse({id: 1}); // { data: object }
Enter fullscreen mode Exit fullscreen mode

Mapped Types for Transformations

type EventHandlers<T> = {
  [K in keyof T as `on${Capitalize<string & K>}`]: (value: T[K]) => void;
};

type FormData = {
  email: string;
  password: string;
  rememberMe: boolean;
};

// Automatically generates:
// {
//   onEmail: (value: string) => void;
//   onPassword: (value: string) => void;
//   onRememberMe: (value: boolean) => void;
// }
type FormHandlers = EventHandlers<FormData>;

const createFormHandlers = <T extends Record<string, any>>(
  onChange: (key: keyof T, value: T[keyof T]) => void
): EventHandlers<T> => {
  return new Proxy({} as EventHandlers<T>, {
    get: (target, prop: string) => {
      if (prop.startsWith('on')) {
        const key = prop.slice(2).toLowerCase() as keyof T;
        return (value: T[keyof T]) => onChange(key, value);
      }
      return undefined;
    }
  });
};
Enter fullscreen mode Exit fullscreen mode

7. Performance and Optimization Patterns

Memoization with Type Safety

type MemoCache<T extends (...args: any[]) => any> = Map<string, ReturnType<T>>;

function memoize<T extends (...args: any[]) => any>(
  fn: T,
  keyGenerator?: (...args: Parameters<T>) => string
): T {
  const cache: MemoCache<T> = new Map();
  const defaultKeyGen = (...args: Parameters<T>) => JSON.stringify(args);
  const keyGen = keyGenerator || defaultKeyGen;

  return ((...args: Parameters<T>): ReturnType<T> => {
    const key = keyGen(...args);

    if (cache.has(key)) {
      return cache.get(key)!;
    }

    const result = fn(...args);
    cache.set(key, result);
    return result;
  }) as T;
}

// Usage
const expensiveCalculation = memoize(
  (x: number, y: number): number => {
    console.log(`Calculating ${x} * ${y}`);
    return x * y;
  }
);
Enter fullscreen mode Exit fullscreen mode

Lazy Evaluation

class Lazy<T> {
  private _value: T | undefined = undefined;
  private _computed = false;

  constructor(private computation: () => T) {}

  get value(): T {
    if (!this._computed) {
      this._value = this.computation();
      this._computed = true;
    }
    return this._value!;
  }

  map<U>(fn: (value: T) => U): Lazy<U> {
    return new Lazy(() => fn(this.value));
  }
}

const lazy = <T>(computation: () => T): Lazy<T> => new Lazy(computation);

// Example usage
const expensiveData = lazy(() => {
  console.log("Computing expensive data...");
  return processLargeDataset();
});

// Only computed when accessed
const result = expensiveData.map(data => data.summary).value;
Enter fullscreen mode Exit fullscreen mode

8. Functional Programming Utilities

Creating a Functional Toolkit

// Partial application
const partial = <T extends any[], U extends any[], R>(
  fn: (...args: [...T, ...U]) => R,
  ...partialArgs: T
) => (...remainingArgs: U): R => fn(...partialArgs, ...remainingArgs);

// Function composition (right to left)
const compose = <T>(...fns: Array<(arg: T) => T>) =>
  (value: T): T => fns.reduceRight((acc, fn) => fn(acc), value);

// Debouncing with proper typing
const debounce = <T extends (...args: any[]) => any>(
  fn: T,
  delay: number
): ((...args: Parameters<T>) => void) => {
  let timeoutId: NodeJS.Timeout;

  return (...args: Parameters<T>) => {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => fn(...args), delay);
  };
};

// Throttling
const throttle = <T extends (...args: any[]) => any>(
  fn: T,
  limit: number
): ((...args: Parameters<T>) => void) => {
  let inThrottle: boolean;

  return (...args: Parameters<T>) => {
    if (!inThrottle) {
      fn(...args);
      inThrottle = true;
      setTimeout(() => inThrottle = false, limit);
    }
  };
};
Enter fullscreen mode Exit fullscreen mode

9. Builder Pattern with Fluent Interface

class QueryBuilder<T> {
  private conditions: string[] = [];
  private sortFields: string[] = [];
  private limitCount?: number;

  where(condition: keyof T, operator: string, value: any): this {
    this.conditions.push(`${String(condition)} ${operator} ${JSON.stringify(value)}`);
    return this;
  }

  orderBy(field: keyof T, direction: 'ASC' | 'DESC' = 'ASC'): this {
    this.sortFields.push(`${String(field)} ${direction}`);
    return this;
  }

  limit(count: number): this {
    this.limitCount = count;
    return this;
  }

  build(): string {
    let query = 'SELECT *';

    if (this.conditions.length > 0) {
      query += ` WHERE ${this.conditions.join(' AND ')}`;
    }

    if (this.sortFields.length > 0) {
      query += ` ORDER BY ${this.sortFields.join(', ')}`;
    }

    if (this.limitCount) {
      query += ` LIMIT ${this.limitCount}`;
    }

    return query;
  }
}

// Usage
const query = new QueryBuilder<User>()
  .where('isActive', '=', true)
  .where('age', '>', 18)
  .orderBy('createdAt', 'DESC')
  .limit(10)
  .build();
Enter fullscreen mode Exit fullscreen mode

10. Best Practices Summary

Function Design Principles

  1. Single Responsibility: Each function should do one thing well
  2. Pure Functions: Prefer functions without side effects when possible
  3. Immutability: Return new objects instead of modifying existing ones
  4. Type Safety: Leverage TypeScript's type system for safer code
  5. Composability: Design functions to work well together

Code Organization

// Group related functions in namespaces or modules
namespace ArrayUtils {
  export const chunk = <T>(array: T[], size: number): T[][] => {
    const chunks: T[][] = [];
    for (let i = 0; i < array.length; i += size) {
      chunks.push(array.slice(i, i + size));
    }
    return chunks;
  };

  export const unique = <T>(array: T[]): T[] => [...new Set(array)];

  export const groupBy = <T, K extends keyof any>(
    array: T[],
    keyFn: (item: T) => K
  ): Record<K, T[]> => {
    return array.reduce((groups, item) => {
      const key = keyFn(item);
      (groups[key] ??= []).push(item);
      return groups;
    }, {} as Record<K, T[]>);
  };
}
Enter fullscreen mode Exit fullscreen mode

Remember: Beautiful functions are not just about clever syntax—they're about creating code that is readable, maintainable, and expresses intent clearly. The goal is to write functions that feel natural to use and easy to understand, even months after you've written them.


This concludes Part 2 of The Art of Beautiful Functions in TypeScript. These patterns will help you write more elegant, type-safe, and maintainable code.

Top comments (0)