Instance Methods

isOk(): this is Ok<A, E>

const result: Result<number, string> = Result.ok(42);

if (result.isOk()) {
  // TypeScript narrows to Ok<number, string>
  console.log(result.value); // 42
}

isErr(): this is Err<T, E>

const result: Result<number, string> = Result.err("failed");

if (result.isErr()) {
  // TypeScript narrows to Err<number, string>
  console.log(result.error); // "failed"
}

map<B>(fn: (a: A) => B): Result<B, E>

// Success case
const result = Result.ok(2).map(x => x * 2);
// Ok(4)

// Error case
const error = Result.err<number, string>("failed").map(x => x * 2);
// Err("failed") - unchanged

// Chaining
Result.ok("hello")
  .map(s => s.toUpperCase())
  .map(s => s.length);
// Ok(5)

mapError<E2>(fn: (e: E) => E2): Result<A, E2>

// Error case
const result = Result.err("not found").mapError(msg => new Error(msg));
// Err(Error("not found"))

// Success case
const success = Result.ok<number, string>(42).mapError(msg => new Error(msg));
// Ok(42) - unchanged

// Normalizing error types
Result.gen(function* () {
  const a = yield* getA(); // Result<A, ErrorA>
  const b = yield* getB(); // Result<B, ErrorB>
  return Result.ok({ a, b });
}).mapError(e => new UnifiedError(e._tag));
// Result<{a, b}, UnifiedError>

andThen<B, E2>(fn: (a: A) => Result<B, E2>): Result<B, E | E2>

// Success case
const result = Result.ok(2).andThen(x => 
  x > 0 ? Result.ok(x * 2) : Result.err("negative")
);
// Ok(4)

// Short-circuit on error
const error = Result.err<number, string>("failed").andThen(x => 
  Result.ok(x * 2)
);
// Err("failed")

// Chaining multiple operations
Result.ok(5)
  .andThen(x => x > 0 ? Result.ok(x) : Result.err("non-positive"))
  .andThen(x => x < 10 ? Result.ok(x * 2) : Result.err("too large"));
// Ok(10)

andThenAsync<B, E2>(
  fn: (a: A) => Promise<Result<B, E2>>
): Promise<Result<B, E | E2>>

// Async operation
const result = await Result.ok(1).andThenAsync(async (id) => {
  const user = await fetchUser(id);
  return Result.ok(user);
});

// Chaining async operations
await Result.ok(userId)
  .andThenAsync(async (id) => {
    const user = await db.getUser(id);
    return user ? Result.ok(user) : Result.err("not found");
  })
  .then(result => result.andThenAsync(async (user) => {
    const profile = await api.getProfile(user.id);
    return Result.ok({ user, profile });
  }));

match<T>(handlers: {
  ok: (a: A) => T;
  err: (e: E) => T;
}): T

// Basic matching
const result: Result<number, string> = Result.ok(42);

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

// Converting to HTTP response
function toResponse(result: Result<Data, AppError>) {
  return result.match({
    ok: (data) => ({ status: 200, body: data }),
    err: (error) => ({ status: error.statusCode, body: { error: error.message } }),
  });
}

// Both handlers must return same type
const num = result.match({
  ok: (n) => n,
  err: () => 0, // Fallback value
});

unwrap(message?: string): A

// Success case
const value = Result.ok(42).unwrap();
// 42

// Error case - throws
Result.err("failed").unwrap();
// throws Panic: "Unwrap called on Err: failed"

// With custom message
Result.err("failed").unwrap("Custom error message");
// throws Panic: "Custom error message"

// Safe usage in tests
test("should return user", () => {
  const result = getUser(id);
  const user = result.unwrap(); // OK in tests
  expect(user.name).toBe("Alice");
});

unwrapOr<B>(fallback: B): A | B

// Success case
const value = Result.ok(42).unwrapOr(0);
// 42

// Error case
const value = Result.err<number, string>("failed").unwrapOr(0);
// 0

// With computed fallback
const name = getUserName(id).unwrapOr("Anonymous");

// In expressions
const total = results
  .map(r => r.unwrapOr(0))
  .reduce((sum, n) => sum + n, 0);

tap(fn: (a: A) => void): Result<A, E>

// Logging during chain
Result.ok(2)
  .tap(x => console.log(`Got value: ${x}`))
  .map(x => x * 2)
  .tap(x => console.log(`Doubled: ${x}`));
// Logs: "Got value: 2", "Doubled: 4"
// Returns: Ok(4)

// Debugging
Result.gen(function* () {
  const user = yield* getUser(id)
    .tap(u => console.log("User fetched:", u));
  
  const profile = yield* getProfile(user.id)
    .tap(p => console.log("Profile fetched:", p));
  
  return Result.ok({ user, profile });
});

// No effect on Err
Result.err<number, string>("failed")
  .tap(x => console.log(x)); // Not executed
// Returns: Err("failed")

tapAsync(fn: (a: A) => Promise<void>): Promise<Result<A, E>>

// Async logging
await Result.ok(user)
  .tapAsync(async (u) => {
    await analytics.track("user_loaded", { id: u.id });
  })
  .then(r => r.map(u => u.profile));

// Async debugging
await Result.gen(async function* () {
  const data = yield* Result.await(
    fetchData(url).tapAsync(async (d) => {
      await logger.info("Data fetched", d);
    })
  );
  return Result.ok(data);
});

// No effect on Err
await Result.err<number, string>("failed")
  .tapAsync(async x => {
    await logValue(x); // Not executed
  });
// Returns: Err("failed")

const result = Result.gen(function* () {
  const a = yield* getA(); // If Err, short-circuits here
  const b = yield* getB(a); // Only runs if getA() was Ok
  return Result.ok({ a, b });
});