Either — two outcomes without throwing

Effect v3.12.0

the Effect<A, E, R> channel order was introduced in The Effect<A, E, R> type ↗

When a function can fail and you do not want to throw, TypeScript leaves you hand-rolling a result union: ok true with a value, or ok false with an error. It works, and the narrowing is real. But every codebase reinvents this shape, and a plain throw would erase the failure from the signature, leaving the caller no warning at all.

Effect ships that union as one type. Either of A and E: Right holds the success of type A, Left holds the failure of type E. That is the same channel order as the first two slots of Effect of A, E, R, so the success-then-failure habit you already have carries straight over.

It composes the same way too. Either.map transforms the Right and leaves a Left untouched. And an Either is just the synchronous, no-requirements cousin of an effect, so inside Effect.gen, yield* pulls the Right out or fails with the Left. The Left lands in E, and the type comes out Effect of number, string, never.

// Plain TypeScript: to return a failure without throwing, you hand-roll a result
// union. Every codebase reinvents this shape, and a plain throw would erase the
// failure from the signature entirely.
type Parsed =
  | { ok: true; value: number }
  | { ok: false; error: string };

const parse = (s: string): Parsed => {
  const n = Number(s);
  return Number.isNaN(n)
    ? { ok: false, error: `not a number: ${s}` }
    : { ok: true, value: n };
};

const result = parse("oops");
//    ^? Parsed

console.log(result.ok ? result.value : result.error); // not a number: oops

❚❚ beat