Beyond the Native Switch: Mastering Method Chaining for Declarative Control Flow

Stop writing nested, imperative control flows. Learn how to build a type-safe, fluent pattern matcher using the Method Chaining pattern in TypeScript.
The native switch statement in JavaScript and TypeScript is a relic of C-style programming. While it gets the job done for basic primitive checks, it quickly turns into an architectural eyesore when your application scales.

Standard switch blocks are strictly imperative. They suffer from scope leakage (unless you wrap every case in blocks {}), require manual break statements (where a single omission introduces catastrophic runtime bugs), and cannot natively evaluate complex, dynamic predicates or functions as case conditions.

To build maintainable, clean enterprise architectures, we should strive for declarative code — code that describes what to do rather than listing step-by-step instructions on how to do it.

In this article, we will dissect how to implement a powerful, type-safe pattern matcher using the Method Chaining (Fluent Interface) pattern, transforming ugly control flows into beautiful, readable expressions.

The Architecture: Fluent Pattern Matcher
By leveraging method chaining, we can create a class that encapsulates the state of the evaluation pipeline and returns this on every conditional step, allowing us to chain operations indefinitely until a termination method (default) resolves the final value.

Here is the elegant, production-ready implementation:

export class Switch<T, R = any> {
  private readonly _value: T;
  private matched: boolean = false;
  private result?: R;

  constructor(value: T) {
    this._value = value;
  }

  case(predicate: T | ((value: T) => boolean), action: () => R): this {
    if (!this.matched) {
      const condition: boolean = typeof predicate === 'function'
        ? (predicate as (value: T) => boolean)(this._value)
        : this._value === predicate;

      if (condition) {
        this.matched = true;
        this.result = action();
      }
    }
    return this;
  }

  default(action: () => R): R {
    if (!this.matched) {
      return action();
    }
    return this.result as R;
  }
}

Deconstructing the Patterns

1. The Method Chaining Pattern (Fluent Interface) The core engine of this class lies in the case method's return statement: return this;. By returning the current instance of the Switch class, we allow the consumer to immediately call another .case() method without breaking the execution flow. The API becomes self-descriptive and fluid:

const userRole = 'PREMIUM_USER';

const discount = new Switch(userRole)
  .case('GUEST', () => 0)
  .case('STANDARD', () => 5)
  .case('PREMIUM_USER', () => 20)
  .default(() => 0);

1. Dynamic Predicates (Functional Pattern Matching) Native switch blocks only support strict equality (===). Your custom Switch utility, however, elevates this by accepting a predicate function (value: T) => boolean. This allows developers to pass inline business rules seamlessly:

const score = 85;

const grade = new Switch(score)
  .case(val => val >= 90, () => 'A')
  .case(val => val >= 80, () => 'B')
  .case(val => val >= 70, () => 'C')
  .default(() => 'F');

1. Short-Circuiting State Guard Traditional implementations evaluate every block unless explicitly interrupted. Your architecture utilizes the private matched: boolean flag as a state guard. Once a condition evaluates to true, the pipeline short-circuits subsequent .case() evaluations, saving CPU cycles and preventing unexpected side effects.

Why This Improves Code Quality
Immutability and Expressions: Instead of declaring a mutable variable (let result;) outside a traditional switch block and mutating it inside, your Switch tool acts as an expression that returns a direct value ready to be assigned to a const.
Zero Scope Contamination: Variables declared inside the case handlers are completely isolated within their respective arrow functions.
No break Accidents: Fall-through bugs are architecturally impossible.
Conclusion
The Method Chaining pattern is a powerful mechanism to replace brittle, imperative structures with readable, functional pipelines. By wrapping conditional logic inside a fluent Switch wrapper, you clean up your domain layer, eliminate boilerplate bugs, and make code review a breeze.

How are you modernizing control flows in your clean code architectures? Let’s discuss in the comments below!