Why is it conventional in Either to place errors on the Left and values on the Right?

This is a functional programming convention based on an English wordplay: 'Right' means both directional right and 'correct/sound'. Consequently, successful values occupy Right, while deviations or errors reside in Left.

Why is throw new Error() considered a violation of pure functions and honest signatures?

The throw operator breaks normal control flow and unwinds the call stack up to the nearest try/catch, bypassing TypeScript's type system. The function signature (id: string) => User obscures the reality that the call may fail abruptly. This compels callers to sprinkle defensive try/catch blocks everywhere or risk uncaught crashes.

What is the difference between map and flatMap in Option / Either?

map accepts a transformation function for normal values (a: A) => B and returns Either . flatMap (also known as chain) accepts a function that itself returns a monadic container: (a: A) => Either . This prevents undesired type nesting like Either > and allows chaining fallible steps linearly.

What is the disadvantage of using Option compared to Either for error handling?

Option only communicates the absence of a value (None), completely losing why the computation failed (whether due to a timeout, authorization failure, or invalid schema). Either preserves full semantic context regarding failure modes via the E type parameter.

How does Either protect against unhandled promise rejections?

With Promise >, the Promise always resolves successfully with either a Right or a Left container. The Promise never enters the rejected state, which eliminates Node.js unhandled rejection crashes and centralizes error handling logic in the Left channel.

How does TypeScript ensure exhaustive checking inside match?

By leveraging discriminated unions (_tag: 'Left' | 'Right'). Inside the match implementation, TypeScript verifies the _tag discriminant. If an engineer forgets a branch or returns an incompatible type, strict noImplicitReturns and union exhaustion prevent compilation.

Can Option and Either be utilized in asynchronous workflows?

Yes, though composing Promise > directly requires repetitive awaiting. Functional libraries solve this by introducing monadic transformers such as TaskEither (or the unified Effect type in Effect-TS), merging asynchronous execution and typed error channels into a single primitive.

Option and Either (Result) Patterns: Type-Safe Error Handling Without throw — TypeScript 5.8+ Mastery

Architectural Foundation#

In conventional JavaScript and TypeScript development, the imperative model of exception handling dominates through the throw statement and try/catch constructs. In enterprise architecture, however, this pattern introduces a fundamental defect: Dishonest Type Signatures.

Consider a classic function signature:

typescript

async function fetchUserProfile(userId: string): Promise<UserProfile> {
  // Can throw NetworkError, ParseError, UnauthorizedError, or NotFoundError
}

The function signature promises that the return value is strictly Promise<UserProfile>. Information regarding potential failure modes is completely concealed from TypeScript's static analysis engine. The compiler cannot force developers to handle exceptions, and within catch (error: unknown), the error type degenerates to unknown, forcing unsafe runtime type assertions.

The functional programming paradigm resolves this challenge by converting errors and missing values into first-class values (Errors as Values):

Option<A> (or Maybe): A deterministic replacement for unpredictable null and undefined.
Either<E, A> (or Result): A type-safe alternative to the imperative throw mechanism.

Mental Model#

Rather than breaking call stacks through hidden throw exceptions, computations are modeled as a two-track pipeline (Railway Oriented Programming):

text

+-------------------------------------------------------------------------+
|                RAILWAY ORIENTED COMPUTATION PIPELINE (EITHER)           |
+-------------------------------------------------------------------------+
| Success Track (Right):                                                  |
| [Input JSON] ---> map(parseDTO) ---> flatMap(validate) ---> Right(User) |
|                          |                   |                          |
|                          v (failure)         v (failure)                |
| Error Track (Left):      |                   |                          |
| [Exception]  ---> Left(SyntaxError)  Left(ValidationError)              |
+-------------------------------------------------------------------------+
                                     |
                                     v
+-------------------------------------------------------------------------+
|                  TERMINAL UNWRAPPING (MATCH / FOLD)                     |
|  match({                                                                |
|    onLeft:  (error) => renderErrorBanner(error), // Strict error branch |
|    onRight: (user)  => renderUserProfile(user)  // Pure User type       |
|  })                                                                     |
+-------------------------------------------------------------------------+

Any error switches execution to the lower track (Left). Subsequent calls to map and flatMap are automatically bypassed, eliminating nested if (err) return boilerplate.

Comparison of Error Handling Models in TypeScript

Критерий	Imperative throw / try-catch	Functional Either / Option (Result)
Type Contract	Incomplete: error types omitted from signature	Complete: error type (E) explicitly declared in Either<E, A>
Compiler Enforcement	None: easily forgot to wrap in try/catch	Strict: compiler disallows unwrapping A without handling E
Error Type in Catch Handler	unknown or any in catch block	Strictly typed domain union (DomainError)
Composition	Stack unwinding, deeply nested try blocks	Linear pipelines via composable combinators (.pipe)

Practical Applications#

Multi-Stage Financial Transaction Validation: Step-by-step verification of ledger balance, anti-fraud limits, and currency exchange without breaking execution flow and with exhaustive error matching.
Resilient External API Clients: Transforming HTTP responses, parsing JSON payloads, and validating HTTP status codes into strictly typed domain models.
Safe Deep Configuration Navigation: Reading deeply nested properties and environment variables via Option without risking TypeError: Cannot read property of undefined.
ETL Data Processing Pipelines: Building reliable analytics and log pipelines where malformed rows are isolated into the error channel without terminating the overall batch.

How It Works#

1. Architecture of Algebraic Types Option and Either#

Here is a reference implementation of Option and Either using discriminated unions with complete TypeScript type safety:

typescriptsrc/functional/Option.ts

export interface Some<A> {
  readonly _tag: 'Some';
  readonly value: A;
}

export interface None {
  readonly _tag: 'None';
}

export type Option<A> = Some<A> | None;

export const Option = {
  some: <A>(value: A): Option<A> => ({ _tag: 'Some', value }),
  none: (): Option<never> => ({ _tag: 'None' }),

  fromNullable: <A>(value: A | null | undefined): Option<NonNullable<A>> =>
    value !== null && value !== undefined
      ? Option.some(value as NonNullable<A>)
      : Option.none(),

  isSome: <A>(fa: Option<A>): fa is Some<A> => fa._tag === 'Some',
  isNone: <A>(fa: Option<A>): fa is None => fa._tag === 'None',

  map: <A, B>(fa: Option<A>, f: (a: A) => B): Option<B> =>
    fa._tag === 'Some' ? Option.some(f(fa.value)) : Option.none(),

  flatMap: <A, B>(fa: Option<A>, f: (a: A) => Option<B>): Option<B> =>
    fa._tag === 'Some' ? f(fa.value) : Option.none(),

  getOrElse: <A>(fa: Option<A>, onNone: () => A): A =>
    fa._tag === 'Some' ? fa.value : onNone(),

  match: <A, B>(fa: Option<A>, onNone: () => B, onSome: (a: A) => B): B =>
    fa._tag === 'Some' ? onSome(fa.value) : onNone(),
};

typescriptsrc/functional/Either.ts

export interface Left<E> {
  readonly _tag: 'Left';
  readonly left: E;
}

export interface Right<A> {
  readonly _tag: 'Right';
  readonly right: A;
}

export type Either<E, A> = Left<E> | Right<A>;

export const Either = {
  left: <E, A = never>(error: E): Either<E, A> => ({ _tag: 'Left', left: error }),
  right: <A, E = never>(value: A): Either<E, A> => ({ _tag: 'Right', right: value }),

  isLeft: <E, A>(ma: Either<E, A>): ma is Left<E> => ma._tag === 'Left',
  isRight: <E, A>(ma: Either<E, A>): ma is Right<A> => ma._tag === 'Right',

  // Safe bridge from imperative throwing code to Either
  tryCatch: <E, A>(
    tryFn: () => A,
    onError: (error: unknown) => E
  ): Either<E, A> => {
    try {
      return Either.right(tryFn());
    } catch (err: unknown) {
      return Either.left(onError(err));
    }
  },

  map: <E, A, B>(ma: Either<E, A>, f: (a: A) => B): Either<E, B> =>
    ma._tag === 'Right' ? Either.right(f(ma.right)) : Either.left(ma.left),

  flatMap: <E, A, B>(ma: Either<E, A>, f: (a: A) => Either<E, B>): Either<E, B> =>
    ma._tag === 'Right' ? f(ma.right) : Either.left(ma.left),

  match: <E, A, B>(
    ma: Either<E, A>,
    onLeft: (error: E) => B,
    onRight: (value: A) => B
  ): B => (ma._tag === 'Left' ? onLeft(ma.left) : onRight(ma.right)),
};

2. Practical Walkthrough: Safe Parsing and Configuration Validation#

Let us build a type-safe user data processing pipeline without throwing a single exception:

typescript

// Strict domain error discriminated union
export type DomainError =
  | { readonly code: 'INVALID_JSON'; readonly raw: string }
  | { readonly code: 'VALIDATION_FAILED'; readonly field: string; readonly reason: string }
  | { readonly code: 'UNAUTHORIZED'; readonly userId: string };

export interface UserAccount {
  readonly id: string;
  readonly email: string;
  readonly balanceCents: number;
}

// 1. Safe string parsing
export function parseRawJson(rawText: string): Either<DomainError, unknown> {
  return Either.tryCatch(
    () => JSON.parse(rawText) as unknown,
    () => ({ code: 'INVALID_JSON', raw: rawText })
  );
}

// 2. Data structure validation
export function validateAccountDto(input: unknown): Either<DomainError, UserAccount> {
  if (typeof input !== 'object' || input === null) {
    return Either.left({
      code: 'VALIDATION_FAILED',
      field: 'root',
      reason: 'Payload must be an object',
    });
  }

  const candidate = input as Record<string, unknown>;

  if (typeof candidate.id !== 'string' || candidate.id.trim() === '') {
    return Either.left({
      code: 'VALIDATION_FAILED',
      field: 'id',
      reason: 'ID must be a non-empty string',
    });
  }

  if (typeof candidate.email !== 'string' || !candidate.email.includes('@')) {
    return Either.left({
      code: 'VALIDATION_FAILED',
      field: 'email',
      reason: 'Invalid email address format',
    });
  }

  if (typeof candidate.balanceCents !== 'number' || candidate.balanceCents < 0) {
    return Either.left({
      code: 'VALIDATION_FAILED',
      field: 'balanceCents',
      reason: 'Balance must be a non-negative integer',
    });
  }

  return Either.right({
    id: candidate.id,
    email: candidate.email,
    balanceCents: candidate.balanceCents,
  });
}

// 3. Pipeline composition
export function processRawAccount(rawJson: string): Either<DomainError, UserAccount> {
  const parsed = parseRawJson(rawJson);
  return Either.flatMap(parsed, validateAccountDto);
}

Architecture Pipeline

Lifecycle of a Computation with Error Isolation in Either

4 stages

Input Ingestion

Input PayloadCore / System

Receive unparsed external data (JSON payload, HTTP headers, storage blobs).

Artifacts:rawJson String

Parsing via Either.tryCatch

Safe ParserCore / System

Wrap hazardous JSON.parse calls into an Either without leaking uncaught exceptions.

Artifacts:Either<DomainError, unknown>

Monadic Validation

flatMap GuardCore / System

Invoke validator upon parsing success; bypass validation completely on error.

Artifacts:Either<DomainError, UserAccount>

Exhaustive Pattern Matching

Either.matchTemplate / UI

Force explicit handling of both branches: return HTTP 400 or proceed with domain logic.

Artifacts:HTTP ResponseType-safe UI State

Production Artifact: Functional Composition Utility (pipe)#

To enable linear composition of functions without nested parenthetical calls, here is a type-safe pipe combinator:

Production Artifactsrc/functional/pipe.ts

Type-safe pipe implementation supporting up to 6 chained transformations.

typescript

export function pipe<A>(a: A): A;
export function pipe<A, B>(a: A, ab: (a: A) => B): B;
export function pipe<A, B, C>(a: A, ab: (a: A) => B, bc: (b: B) => C): C;
export function pipe<A, B, C, D>(a: A, ab: (a: A) => B, bc: (b: B) => C, cd: (c: C) => D): D;
export function pipe<A, B, C, D, E>(
  a: A,
  ab: (a: A) => B,
  bc: (b: B) => C,
  cd: (c: C) => D,
  de: (d: D) => E
): E;
export function pipe<A, B, C, D, E, F>(
  a: A,
  ab: (a: A) => B,
  bc: (b: B) => C,
  cd: (c: C) => D,
  de: (d: D) => E,
  ef: (e: E) => F
): F;
export function pipe(
  value: unknown,
  ...fns: ReadonlyArray<(arg: unknown) => unknown>
): unknown {
  return fns.reduce((acc, fn) => fn(acc), value);
}

Application in enterprise code:

typescript

import { pipe } from '@/functional/pipe';

const result = pipe(
  '{"id":"usr_42","email":"[email protected]","balanceCents":1500}',
  parseRawJson,
  (either) => Either.flatMap(either, validateAccountDto),
  (either) =>
    Either.match(
      either,
      (err) => `Processing error: ${err.code}`,
      (acc) => `Profile successfully loaded: ${acc.email} ($${acc.balanceCents / 100})`
    )
);

Common Pitfalls#

Ошибка: Forced Unwrapping Without Discriminator Tag Checking

Directly accessing fa.value or ma.right without verifying _tag === 'Some' or _tag === 'Right' destroys type safety and yields undefined at runtime.

typescript

// ❌ Anti-pattern: Direct field access on Either
function unsafeUnwrap(result: Either<string, number>): number {
  // Compiles in TypeScript, but yields runtime undefined if result is Left!
  return (result as { right: number }).right;
}

// ✅ Correct approach: Use match or getOrElse
function safeUnwrap(result: Either<string, number>): number {
  return Either.match(
    result,
    (err) => 0, // Fallback on error
    (val) => val
  );
}

Ошибка: Invoking throw Inside map or flatMap Callbacks

Calling throw new Error() inside a pure callback passed to Either.map ruptures pipeline encapsulation, breaks the call stack, and renders the error invisible to the type system. Solution: Any operation capable of throwing must be wrapped in Either.tryCatch.

Ошибка: Mixing null, undefined, and Option in the Same Abstraction Layer

Returning Option<T | null> introduces duplicate uncertainty. Normalize values immediately at the system boundary using Option.fromNullable(val), and work strictly with Option<T> thereafter.

Step-by-Step Migration from try/catch to Either#

Refactoring Imperative Error Handling to Either Tracks

Model Domain ErrorsError Modeling

Define a discriminated union of domain errors (DomainError) with a unique string literal code tag.

Wrap External APIs in Either.tryCatchIsolation

Replace raw fetch, JSON.parse, and fs calls with functions returning Either<E, A>.

Chain Steps via flatMapComposition

Compose a linear execution track passing output from one step into the next via Either.flatMap.

Terminal Unwrapping with matchPattern Matching

At the boundary of the application (HTTP controller, UI handler), call match for exhaustive error and success handling.

Remove Redundant try/catch BlocksCleanup

Delete legacy error-swallowing try/catch blocks to produce clean, deterministic call stacks.

Interview Questions & Answers#

Interview Questions7 questions

Option and Either (Result) Patterns: Type-Safe Error Handling Without throw

Architectural Foundation#

Mental Model#

Practical Applications#

How It Works#

1. Architecture of Algebraic Types Option and Either#

2. Practical Walkthrough: Safe Parsing and Configuration Validation#

Lifecycle of a Computation with Error Isolation in Either

Input Ingestion

Parsing via Either.tryCatch

Monadic Validation

Exhaustive Pattern Matching

Production Artifact: Functional Composition Utility (pipe)#

Common Pitfalls#

Ошибка: Forced Unwrapping Without Discriminator Tag Checking

Ошибка: Invoking throw Inside map or flatMap Callbacks

Ошибка: Mixing null, undefined, and Option in the Same Abstraction Layer

Step-by-Step Migration from try/catch to Either#

Interview Questions & Answers#

Related Topics#

Architectural Foundation#

Mental Model#

Practical Applications#

How It Works#

1. Architecture of Algebraic Types Option and Either#

2. Practical Walkthrough: Safe Parsing and Configuration Validation#

Lifecycle of a Computation with Error Isolation in Either

Input Ingestion

Parsing via Either.tryCatch

Monadic Validation

Exhaustive Pattern Matching

Production Artifact: Functional Composition Utility (pipe)#

Common Pitfalls#

Ошибка: Forced Unwrapping Without Discriminator Tag Checking

Ошибка: Invoking throw Inside map or flatMap Callbacks

Ошибка: Mixing null, undefined, and Option in the Same Abstraction Layer

Step-by-Step Migration from try/catch to Either#

Interview Questions & Answers#

Related Topics#