Result & Either Patterns

Why a Result Type

throw carries no type information — callers cannot see failure without reading the body, and try/catch cannot distinguish error kinds statically:

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

async function parseConfig(raw: string): Promise<Result<Config, ParseIssue>> {
  try {
    return { ok: true, value: JSON.parse(raw) as Config };
  } catch (err) {
    return { ok: false, error: toIssue(err) };
  }
}

const r = await parseConfig(text);
if (r.ok) {
  r.value;    // Config  — narrowed by the literal discriminant
} else {
  r.error;    // ParseIssue
}

The ok: true/ok: false literal types are what make narrowing work; a status: string field would not. Failures become values you must handle, which flows through function signatures and shows up in every call site.

Combinators Without Any

Small generic helpers chain Results fluently:

const map = <T, U, E>(r: Result<T, E>, f: (v: T) => U): Result<U, E> =>
  r.ok ? { ok: true, value: f(r.value) } : r;

const andThen = <T, U, E>(
  r: Result<T, E>,
  f: (v: T) => Result<U, E>,
): Result<U, E> => (r.ok ? f(r.value) : r);

const unwrapOr = <T, E>(r: Result<T, E>, fallback: T): T =>
  r.ok ? r.value : fallback;

const fromThrowable = <T>(f: () => T): Result<T, unknown> => {
  try { return { ok: true, value: f() }; }
  catch (err) { return { ok: false, error: err }; }
};

map transforms success; andThen (flatMap) sequences operations that themselves can fail — the difference mirrors Promise then chains. match collapses to a single output:

const msg = r.ok ? `ok: ${r.value}` : `failed: ${r.error.message}`;

Pitfalls and Interview Angles

• Mixed styles: Result plus still-throwing helpers gives double handling — pick per layer (Result for domain failures, exceptions for programmer errors).
• E/E unknown: choose E = unknown at untrusted boundaries and narrow; E = Error where you own construction. Never any — it kills the point.
• Exhaustiveness: a final never check catches missed variants when you add a third state:

function assertNever(x: never): never {
  throw new Error(`unhandled: ${JSON.stringify(x)}`);
}
switch (r.kind) { case "ok": ...; case "err": ...; default: return assertNever(r); }

• Interop: libraries expect throws — unwrap at the outermost boundary with a policy mapping E to status codes.

Interview angle: refactor getUser(id: string): User (throws NotFoundError, NetworkError) into a Result, then show narrowing and the HTTP mapping.