ok() and err()

function ok(): Ok<void, never>
function ok<A, E = never>(value: A): Ok<A, E>

import { Result } from "better-result";

const result = Result.ok(42);
// Result: Ok<number, never>

console.log(result.status); // "ok"
console.log(result.value);  // 42

const result = Result.ok();
// Result: Ok<void, never>

// Useful for side-effectful operations that don't return a value
function logMessage(msg: string): Result<void, IoError> {
  console.log(msg);
  return Result.ok();
}

type AppError = "NetworkError" | "ValidationError";

const result = Result.ok<number, AppError>(42);
// Result: Ok<number, AppError>

function err<T = never, E = unknown>(error: E): Err<T, E>

import { Result } from "better-result";

const result = Result.err("Something went wrong");
// Result: Err<never, string>

console.log(result.status); // "error"
console.log(result.error);  // "Something went wrong"

import { TaggedError } from "better-result";

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

const result = Result.err(new ValidationError("email", "Invalid format"));
// Result: Err<never, ValidationError>

interface User {
  id: string;
  name: string;
}

const result = Result.err<User, string>("User not found");
// Result: Err<User, string>

// Ok<A, E> - A is real, E is phantom
const success = Result.ok<number, string>(42);

// Err<T, E> - T is phantom, E is real
const failure = Result.err<number, string>("error");

function divide(a: number, b: number): Result<number, string> {
  if (b === 0) {
    // Err needs phantom type <number> to match function return type
    return Result.err<number, string>("Division by zero");
  }
  return Result.ok<number, string>(a / b);
}

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

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

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

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

function parseAge(input: string): Result<number, string> {
  const age = parseInt(input, 10);
  
  if (isNaN(age)) {
    return Result.err("Invalid number");
  }
  
  if (age < 0 || age > 150) {
    return Result.err("Age out of range");
  }
  
  return Result.ok(age);
}

function validateUser(data: unknown): Result<User, ValidationError> {
  if (!data || typeof data !== "object") {
    return Result.err(new ValidationError("Invalid data"));
  }
  
  if (!('id' in data) || typeof data.id !== "string") {
    return Result.err(new ValidationError("Missing or invalid id"));
  }
  
  return Result.ok(data as User);
}

type AppError = 
  | { _tag: "NetworkError"; statusCode: number }
  | { _tag: "ValidationError"; field: string }
  | { _tag: "NotFoundError"; id: string };

function handleError(error: AppError): string {
  switch (error._tag) {
    case "NetworkError":
      return `HTTP ${error.statusCode}`;
    case "ValidationError":
      return `Invalid ${error.field}`;
    case "NotFoundError":
      return `Not found: ${error.id}`;
  }
}

const result = Result.err<User, AppError>({
  _tag: "NotFoundError",
  id: "user-123"
});