Getting Started

import { Result } from "@carbonteq/fp";

type Config = { host: string; port: number };
type ConfigError = { field: string; message: string };

function parseConfig(env: Record<string, string>): Result<Config, ConfigError> {
  const host = env.HOST;
  if (!host) return Result.Err({ field: "HOST", message: "required" });

  const port = Number(env.PORT);
  if (!Number.isInteger(port) || port < 1 || port > 65535) {
    return Result.Err({ field: "PORT", message: "must be 1-65535" });
  }

  return Result.Ok({ host, port });
}

const config = parseConfig({ HOST: "localhost", PORT: "3000" });
       
const config: Result<Config, ConfigError>

// Transform the success value
const url = config.map((c) => `http://${c.host}:${c.port}`);

// Provide a fallback
const fallback = config.unwrapOr({ host: "127.0.0.1", port: 8080 });

// Handle both cases
const message = config.match({
  Ok: (c) => `Server at ${c.host}:${c.port}`,
  Err: (e) => `Config error in ${e.field}: ${e.message}`,
});

import { Option } from "@carbonteq/fp";

type User = { id: string; email: string; verified: boolean };

declare function findUserById(id: string): User | null;

function getVerifiedEmail(userId: string): Option<string> {
  return Option.fromNullable(findUserById(userId))
    .filter((u) => u.verified)
    .map((u) => u.email);
}

const email = getVerifiedEmail("user-123");
      
const email: Option<string>

// Provide a default
const display = email.unwrapOr("no verified email");

// Convert to Result for error context
const result = email.toResult("User not found or not verified");

import { Result } from "@carbonteq/fp";

type Order = { userId: string; amount: number };
type Receipt = { orderId: string; total: number };

declare function validateUser(userId: string): Result<string, string>;
declare function checkBalance(userId: string, amount: number): Result<number, string>;

function processOrder(order: Order): Result<Receipt, string> {
  return Result.Ok(order)
    .flatMap((o) => validateUser(o.userId).map(() => o))
    .flatMap((o) => checkBalance(o.userId, o.amount).map((bal) => ({ ...o, bal })))
    .map((o) => ({
      orderId: `ORD-${Date.now()}`,
      total: o.amount,
    }))
    .tap((r) => console.log(`Created order ${r.orderId}`))
    .tapErr((e) => console.error(`Order failed: ${e}`));
}

import { Result, Option, matchRes, matchOpt } from "@carbonteq/fp";

declare function fetchData(): Result<{ items: string[] }, Error>;
declare function getCached(): Option<string[]>;

// Match on Result
const data = fetchData();
const items = matchRes(data, {
  Ok: (d) => d.items,
  Err: (e) => {
    console.error(e.message);
    return [];
  },
});

// Match on Option
const cached = getCached();
const list = matchOpt(cached, {
  Some: (items) => items,
  None: () => [],
});

import { Result } from "@carbonteq/fp";

// Sync: wrap JSON.parse
const parseJson = (input: string) =>
  Result.tryCatch(
    () => JSON.parse(input) as unknown,
    (e) => (e instanceof Error ? e : new Error("Parse failed")),
  );

const parsed = parseJson('{"ok": true}');
       
const parsed: Result<unknown, Error>

// Async: wrap fetch
async function fetchUser(id: string) {
  return Result.tryAsyncCatch(
    async () => {
      const res = await fetch(`/api/users/${id}`);
      if (!res.ok) throw new Error(`HTTP ${res.status}`);
      return res.json() as Promise<{ name: string }>;
    },
    (e) => (e instanceof Error ? e : new Error("Fetch failed")),
  ).toPromise();
}