Result<T, E>

type Result<T, E> = Ok<T, E> | Err<T, E>

class Ok<A, E = never> {
  readonly status: "ok";
  readonly value: A;
}

class Err<T, E> {
  readonly status: "error";
  readonly error: E;
}

type InferOk<R> = R extends Ok<infer T, unknown> ? T : never

type MyResult = Result<number, string>;
type Value = InferOk<MyResult>; // number

type InferErr<R> = R extends Err<unknown, infer E> ? E : never

type MyResult = Result<number, string>;
type Error = InferErr<MyResult>; // string

const result: Result<number, string> = getValue();

if (result.status === "ok") {
  // TypeScript narrows to Ok<number, string>
  console.log(result.value); // number
} else {
  // TypeScript narrows to Err<number, string>
  console.log(result.error); // string
}

import { Result } from "better-result";

// Success case
const success: Result<number, string> = Result.ok(42);

// Error case
const failure: Result<number, string> = Result.err("Something went wrong");

class ValidationError extends TaggedError<"ValidationError"> {
  readonly _tag = "ValidationError";
  constructor(public field: string, public message: string) {
    super();
  }
}

type ValidateResult = Result<User, ValidationError>;

function validateUser(data: unknown): ValidateResult {
  if (!data || typeof data !== "object") {
    return Result.err(new ValidationError("user", "Invalid data"));
  }
  return Result.ok(data as User);
}

const result: Result<number, string> = performOperation();

const output = result.match({
  ok: (value) => `Success: ${value}`,
  err: (error) => `Error: ${error}`,
});

const result = Result.gen(function* () {
  const a = yield* getUserId();    // Ok<string, DbError>
  const b = yield* getUser(a);     // Ok<User, ApiError>
  return Result.ok({ a, b });
});
// result: Result<{a: string, b: User}, DbError | ApiError>