nalloc 0.0.1

package/README.md

@@ -0,0 +1,282 @@
+# nalloc
+
+**Rust-like safety at JavaScript speed.**
+
+Type-safe `Option` and `Result` for TypeScript with near-zero allocations for extreme performance.
+
+[![npm version](https://img.shields.io/npm/v/nalloc.svg)](https://www.npmjs.com/package/nalloc)
+[![npm downloads](https://img.shields.io/npm/dw/nalloc.svg)](https://www.npmjs.com/package/nalloc)
+
+## Why nalloc?
+
+Most Option/Result libraries wrap every value in an object. nalloc doesn't.
+
+```
+Other libraries:    Some(42) --> { _tag: 'Some', value: 42 }   // allocates
+nalloc:            Some(42) --> 42                            // zero allocation
+
+Other libraries:    Ok(data) --> { _tag: 'Ok', value: data }   // allocates
+nalloc:            Ok(data) --> data                          // zero allocation
+```
+
+- **Rust-like types** - `Option<T>` and `Result<T, E>` with full pattern matching and combinators
+- **Near-zero allocations** - `Some` and `Ok` are the values themselves. Only `Err` allocates.
+- **Extreme performance** - Up to 2x faster than alternatives on the happy path
+
+## Benchmarks
+
+| Operation | nalloc | neverthrow | ts-results | oxide.ts |
+|-----------|---------|------------|------------|----------|
+| `ok()` | **91M ops/s** | 75M ops/s | 56M ops/s | 40M ops/s |
+| `err()` | **55M ops/s** | 52M ops/s | 0.1M ops/s | 47M ops/s |
+| `some()` | **85M ops/s** | - | 40M ops/s | 50M ops/s |
+| `Result.map` | **74M ops/s** | 53M ops/s | 47M ops/s | 64M ops/s |
+| `Option.map` | **71M ops/s** | - | 52M ops/s | 41M ops/s |
+
+Run `pnpm bench` to reproduce.
+
+## Install
+
+```bash
+npm install nalloc
+```
+
+## Quick start
+
+```ts
+import { Option, Result, ok, err, none } from 'nalloc';
+
+// Option: the value IS the Option
+const port = Option.fromNullable(process.env.PORT);
+const portNum = Option.unwrapOr(port, '3000');
+
+// Result: Ok is the value itself, Err wraps the error
+const config = Result.tryCatch(() => JSON.parse(raw), () => 'invalid json');
+const data = Result.match(
+  config,
+  cfg => cfg,
+  error => ({ fallback: true })
+);
+```
+
+## How it works
+
+| Type | Representation | Allocation |
+|------|----------------|------------|
+| `Option<T>` | `T \| null \| undefined` | Zero |
+| `Some<T>` | The value itself | Zero |
+| `None` | `null` or `undefined` | Zero |
+| `Ok<T>` | The value itself (branded) | Zero |
+| `Err<E>` | Minimal wrapper `{ error: E }` | One object |
+
+This means zero GC pressure on the happy path - your success values stay as plain values.
+
+## Coming from other libraries?
+
+### From neverthrow
+
+```ts
+// neverthrow
+import { ok, err, Result } from 'neverthrow';
+const result: Result<number, string> = ok(42);
+result.map(x => x * 2);
+
+// nalloc - same concepts, faster execution
+import { Result, ok, err } from 'nalloc';
+const result = ok(42);                    // zero allocation
+Result.map(result, x => x * 2);           // function-based API
+```
+
+### From fp-ts
+
+```ts
+// fp-ts
+import { pipe } from 'fp-ts/function';
+import * as O from 'fp-ts/Option';
+pipe(O.some(42), O.map(x => x * 2));
+
+// nalloc - simpler, faster
+import { Option } from 'nalloc';
+Option.map(42, x => x * 2);               // value IS the Option
+```
+
+### From Rust
+
+The API mirrors Rust's `Option` and `Result`:
+
+```ts
+import { Option, Result, ok, err, none } from 'nalloc';
+
+// Rust: Some(42).map(|x| x * 2)
+Option.map(42, x => x * 2);
+
+// Rust: Ok(42).and_then(|x| if x > 0 { Ok(x) } else { Err("negative") })
+Result.andThen(ok(42), x => x > 0 ? ok(x) : err('negative'));
+
+// Rust: result.unwrap_or(0)
+Result.unwrapOr(result, 0);
+```
+
+## Option
+
+An `Option<T>` is `T | null | undefined`. The value itself is the Option.
+
+```ts
+import { Option, none } from 'nalloc';
+
+// Create from nullable
+const maybePort = Option.fromNullable(process.env.PORT);
+
+// Transform
+const doubled = Option.map(maybePort, p => parseInt(p) * 2);
+const validated = Option.filter(doubled, n => n > 0);
+
+// Extract
+const port = Option.unwrapOr(maybePort, '3000');
+
+// Pattern match
+const label = Option.match(
+  maybePort,
+  value => `Port: ${value}`,
+  () => 'Port: default'
+);
+
+// Assert and narrow
+Option.assertSome(maybePort, 'PORT is required');
+
+// Filter collections
+const activeIds = Option.filterMap(users, user =>
+  user.isActive ? user.id : none
+);
+
+// Async
+const maybeUser = await Option.fromPromise(fetchUserById(id));
+```
+
+## Result
+
+A `Result<T, E>` is either `Ok<T>` (the value itself) or `Err<E>` (a wrapper).
+
+```ts
+import { Result, ok, err } from 'nalloc';
+
+// Wrap throwing functions
+const parsed = Result.tryCatch(
+  () => JSON.parse(raw),
+  e => 'invalid json'
+);
+
+// Async operations
+const data = await Result.fromPromise(fetch('/api'));
+const processed = await Result.tryAsync(async () => {
+  const res = await fetch('/api');
+  return res.json();
+});
+
+// Transform
+const userId = Result.map(parsed, data => data.userId);
+const validated = Result.flatMap(userId, id =>
+  id > 0 ? ok(id) : err('invalid id')
+);
+
+// Pattern match
+const user = Result.match(
+  parsed,
+  data => data.user,
+  error => null
+);
+
+// Assert and narrow
+Result.assertOk(loaded, 'Config required');
+
+// Collections
+const combined = Result.all([ok(1), ok(2), ok(3)]);      // Ok([1, 2, 3])
+const first = Result.any([err('a'), ok(42), err('b')]);  // Ok(42)
+const [oks, errs] = Result.partition(results);
+```
+
+## API Reference
+
+### Option
+
+| Function | Description |
+|----------|-------------|
+| `fromNullable(value)` | Convert nullable to Option |
+| `fromPromise(promise)` | Promise to Option (rejection = None) |
+| `map(opt, fn)` | Transform Some value |
+| `flatMap(opt, fn)` | Chain Option-returning functions |
+| `filter(opt, predicate)` | Keep Some if predicate passes |
+| `match(opt, onSome, onNone)` | Pattern match |
+| `unwrap(opt)` | Extract or throw |
+| `unwrapOr(opt, default)` | Extract or default |
+| `unwrapOrElse(opt, fn)` | Extract or compute default |
+| `assertSome(opt, msg?)` | Assert and narrow to Some |
+| `isSome(opt)` / `isNone(opt)` | Type guards |
+| `filterMap(items, fn)` | Map and filter in one pass |
+
+### Result
+
+| Function | Description |
+|----------|-------------|
+| `tryCatch(fn, onError?)` | Wrap throwing function |
+| `tryAsync(fn, onError?)` | Wrap async function |
+| `fromPromise(promise)` | Promise to Result |
+| `map(result, fn)` | Transform Ok value |
+| `mapErr(result, fn)` | Transform Err value |
+| `flatMap(result, fn)` | Chain Result-returning functions |
+| `match(result, onOk, onErr)` | Pattern match |
+| `unwrap(result)` | Extract Ok or throw |
+| `unwrapOr(result, default)` | Extract Ok or default |
+| `assertOk(result, msg?)` | Assert and narrow to Ok |
+| `isOk(result)` / `isErr(result)` | Type guards |
+| `all(results)` | Collect all Ok or first Err |
+| `any(results)` | First Ok or all Errs |
+| `partition(results)` | Split into [oks, errs] |
+| `partitionAsync(promises)` | Async partition |
+
+## Testing
+
+```ts
+import { expectOk, expectErr, expectSome, expectNone, extendExpect } from 'nalloc/testing';
+import { expect } from 'vitest';
+
+extendExpect(expect);
+
+expect(result).toBeOk();
+expect(result).toBeErr();
+expect(option).toBeSome();
+expect(option).toBeNone();
+
+const value = expectOk(result);  // returns value or throws
+```
+
+## Devtools
+
+```ts
+import { formatResult, formatOption, inspectResult, inspectOption } from 'nalloc/devtools';
+
+formatResult(ok(42));    // "Ok(42)"
+formatOption(null);      // "None"
+
+inspectResult(ok(42));   // { status: 'ok', value: 42 }
+inspectOption(42);       // { kind: 'some', value: 42 }
+```
+
+## Comparison
+
+| Feature | nalloc | neverthrow | fp-ts | oxide.ts |
+|---------|---------|------------|-------|----------|
+| Zero-alloc Option | Yes | No | No | No |
+| Zero-alloc Ok | Yes | No | No | No |
+| Bundle size | Tiny | Small | Large | Small |
+| Learning curve | Low | Low | High | Low |
+| Async support | Yes | Yes | Yes | Limited |
+| Tree-shakeable | Yes | Yes | Yes | Yes |
+
+## License
+
+MIT
+
+## Contributing
+
+Contributions welcome! Open an issue or PR for ideas, bug fixes, or docs.

package/build/devtools.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get formatOption () {
+        return formatOption;
+    },
+    get formatResult () {
+        return formatResult;
+    },
+    get inspectOption () {
+        return inspectOption;
+    },
+    get inspectResult () {
+        return inspectResult;
+    },
+    get logOption () {
+        return logOption;
+    },
+    get logResult () {
+        return logResult;
+    },
+    get toJSONOption () {
+        return toJSONOption;
+    },
+    get toJSONResult () {
+        return toJSONResult;
+    }
+});
+const _typescjs = require("./types.cjs");
+function formatOption(opt) {
+    return (0, _typescjs.isSome)(opt) ? `Some(${String(opt)})` : 'None';
+}
+function formatResult(result) {
+    if ((0, _typescjs.isOk)(result)) {
+        return `Ok(${String(result)})`;
+    }
+    const error = result.error;
+    return `Err(${error instanceof Error ? error.message : String(error)})`;
+}
+function inspectOption(opt) {
+    return (0, _typescjs.isSome)(opt) ? {
+        kind: 'some',
+        value: opt
+    } : {
+        kind: 'none'
+    };
+}
+function inspectResult(result) {
+    return (0, _typescjs.isOk)(result) ? {
+        status: 'ok',
+        value: result
+    } : {
+        status: 'err',
+        error: result.error
+    };
+}
+function logOption(opt, logger = console.log) {
+    logger(formatOption(opt));
+}
+function logResult(result, logger = console.log) {
+    const tagged = inspectResult(result);
+    if (tagged.status === 'ok') {
+        logger(`Ok`, tagged.value);
+        return;
+    }
+    logger(`Err`, tagged.error);
+}
+const toJSONOption = inspectOption;
+const toJSONResult = inspectResult;
+
+//# sourceMappingURL=devtools.cjs.map

package/build/devtools.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/devtools.ts"],"sourcesContent":["import { Option, Result, isSome, isOk } from './types.js';\n\n/** Logger function signature for custom logging. */\ntype Logger = (message: string, ...args: unknown[]) => void;\n\n/**\n * Formats an Option as a human-readable string.\n * @param opt - The Option to format\n * @returns \"Some(value)\" or \"None\"\n * @example\n * formatOption(42)        // \"Some(42)\"\n * formatOption(null)      // \"None\"\n * formatOption(undefined) // \"None\"\n */\nexport function formatOption<T>(opt: Option<T>): string {\n  return isSome(opt) ? `Some(${String(opt)})` : 'None';\n}\n\n/**\n * Formats a Result as a human-readable string.\n * For Err containing an Error, displays the error message.\n * @param result - The Result to format\n * @returns \"Ok(value)\" or \"Err(error)\"\n * @example\n * formatResult(42)                      // \"Ok(42)\"\n * formatResult(err('fail'))             // \"Err(fail)\"\n * formatResult(err(new Error('oops')))  // \"Err(oops)\"\n */\nexport function formatResult<T, E>(result: Result<T, E>): string {\n  if (isOk(result)) {\n    return `Ok(${String(result)})`;\n  }\n  const error = (result as { error: E }).error;\n  return `Err(${error instanceof Error ? error.message : String(error)})`;\n}\n\n/**\n * Inspects an Option, returning a tagged object for debugging or serialization.\n * @param opt - The Option to inspect\n * @returns `{ kind: 'some', value: T }` or `{ kind: 'none' }`\n * @example\n * inspectOption(42)   // { kind: 'some', value: 42 }\n * inspectOption(null) // { kind: 'none' }\n */\nexport function inspectOption<T>(opt: Option<T>) {\n  return isSome(opt) ? { kind: 'some' as const, value: opt } : { kind: 'none' as const };\n}\n\n/**\n * Inspects a Result, returning a tagged object for debugging or serialization.\n * @param result - The Result to inspect\n * @returns `{ status: 'ok', value: T }` or `{ status: 'err', error: E }`\n * @example\n * inspectResult(42)           // { status: 'ok', value: 42 }\n * inspectResult(err('fail'))  // { status: 'err', error: 'fail' }\n */\nexport function inspectResult<T, E>(result: Result<T, E>) {\n  return isOk(result) ? { status: 'ok' as const, value: result } : { status: 'err' as const, error: (result as { error: E }).error };\n}\n\n/**\n * Logs an Option using the provided logger (defaults to console.log).\n * @param opt - The Option to log\n * @param logger - The logging function to use\n * @example\n * logOption(42)              // logs \"Some(42)\"\n * logOption(null)            // logs \"None\"\n * logOption(42, console.warn) // logs \"Some(42)\" as warning\n */\nexport function logOption<T>(opt: Option<T>, logger: Logger = console.log): void {\n  logger(formatOption(opt));\n}\n\n/**\n * Logs a Result using the provided logger (defaults to console.log).\n * Logs \"Ok\" with the value or \"Err\" with the error.\n * @param result - The Result to log\n * @param logger - The logging function to use\n * @example\n * logResult(42)              // logs \"Ok\", 42\n * logResult(err('fail'))     // logs \"Err\", \"fail\"\n * logResult(42, console.warn) // logs \"Ok\", 42 as warning\n */\nexport function logResult<T, E>(result: Result<T, E>, logger: Logger = console.log): void {\n  const tagged = inspectResult(result);\n  if (tagged.status === 'ok') {\n    logger(`Ok`, tagged.value);\n    return;\n  }\n  logger(`Err`, tagged.error);\n}\n\n/** Alias for inspectOption. Returns a JSON-serializable representation. */\nexport const toJSONOption = inspectOption;\n\n/** Alias for inspectResult. Returns a JSON-serializable representation. */\nexport const toJSONResult = inspectResult;\n"],"names":["formatOption","formatResult","inspectOption","inspectResult","logOption","logResult","toJSONOption","toJSONResult","opt","isSome","String","result","isOk","error","Error","message","kind","value","status","logger","console","log","tagged"],"mappings":";;;;;;;;;;;QAcgBA;eAAAA;;QAcAC;eAAAA;;QAgBAC;eAAAA;;QAYAC;eAAAA;;QAaAC;eAAAA;;QAcAC;eAAAA;;QAUHC;eAAAA;;QAGAC;eAAAA;;;0BAhGgC;AActC,SAASP,aAAgBQ,GAAc;IAC5C,OAAOC,IAAAA,gBAAM,EAACD,OAAO,CAAC,KAAK,EAAEE,OAAOF,KAAK,CAAC,CAAC,GAAG;AAChD;AAYO,SAASP,aAAmBU,MAAoB;IACrD,IAAIC,IAAAA,cAAI,EAACD,SAAS;QAChB,OAAO,CAAC,GAAG,EAAED,OAAOC,QAAQ,CAAC,CAAC;IAChC;IACA,MAAME,QAAQ,AAACF,OAAwBE,KAAK;IAC5C,OAAO,CAAC,IAAI,EAAEA,iBAAiBC,QAAQD,MAAME,OAAO,GAAGL,OAAOG,OAAO,CAAC,CAAC;AACzE;AAUO,SAASX,cAAiBM,GAAc;IAC7C,OAAOC,IAAAA,gBAAM,EAACD,OAAO;QAAEQ,MAAM;QAAiBC,OAAOT;IAAI,IAAI;QAAEQ,MAAM;IAAgB;AACvF;AAUO,SAASb,cAAoBQ,MAAoB;IACtD,OAAOC,IAAAA,cAAI,EAACD,UAAU;QAAEO,QAAQ;QAAeD,OAAON;IAAO,IAAI;QAAEO,QAAQ;QAAgBL,OAAO,AAACF,OAAwBE,KAAK;IAAC;AACnI;AAWO,SAAST,UAAaI,GAAc,EAAEW,SAAiBC,QAAQC,GAAG;IACvEF,OAAOnB,aAAaQ;AACtB;AAYO,SAASH,UAAgBM,MAAoB,EAAEQ,SAAiBC,QAAQC,GAAG;IAChF,MAAMC,SAASnB,cAAcQ;IAC7B,IAAIW,OAAOJ,MAAM,KAAK,MAAM;QAC1BC,OAAO,CAAC,EAAE,CAAC,EAAEG,OAAOL,KAAK;QACzB;IACF;IACAE,OAAO,CAAC,GAAG,CAAC,EAAEG,OAAOT,KAAK;AAC5B;AAGO,MAAMP,eAAeJ;AAGrB,MAAMK,eAAeJ"}

package/build/devtools.d.ts

@@ -0,0 +1,82 @@
+import { Option, Result } from './types.js';
+/** Logger function signature for custom logging. */
+type Logger = (message: string, ...args: unknown[]) => void;
+/**
+ * Formats an Option as a human-readable string.
+ * @param opt - The Option to format
+ * @returns "Some(value)" or "None"
+ * @example
+ * formatOption(42)        // "Some(42)"
+ * formatOption(null)      // "None"
+ * formatOption(undefined) // "None"
+ */
+export declare function formatOption<T>(opt: Option<T>): string;
+/**
+ * Formats a Result as a human-readable string.
+ * For Err containing an Error, displays the error message.
+ * @param result - The Result to format
+ * @returns "Ok(value)" or "Err(error)"
+ * @example
+ * formatResult(42)                      // "Ok(42)"
+ * formatResult(err('fail'))             // "Err(fail)"
+ * formatResult(err(new Error('oops')))  // "Err(oops)"
+ */
+export declare function formatResult<T, E>(result: Result<T, E>): string;
+/**
+ * Inspects an Option, returning a tagged object for debugging or serialization.
+ * @param opt - The Option to inspect
+ * @returns `{ kind: 'some', value: T }` or `{ kind: 'none' }`
+ * @example
+ * inspectOption(42)   // { kind: 'some', value: 42 }
+ * inspectOption(null) // { kind: 'none' }
+ */
+export declare function inspectOption<T>(opt: Option<T>): {
+    kind: "some";
+    value: import("./types.js").Some<Exclude<T, import("./types.js").NoneValueType>>;
+} | {
+    kind: "none";
+    value?: undefined;
+};
+/**
+ * Inspects a Result, returning a tagged object for debugging or serialization.
+ * @param result - The Result to inspect
+ * @returns `{ status: 'ok', value: T }` or `{ status: 'err', error: E }`
+ * @example
+ * inspectResult(42)           // { status: 'ok', value: 42 }
+ * inspectResult(err('fail'))  // { status: 'err', error: 'fail' }
+ */
+export declare function inspectResult<T, E>(result: Result<T, E>): {
+    status: "ok";
+    value: import("./types.js").Ok<T>;
+    error?: undefined;
+} | {
+    status: "err";
+    error: E;
+    value?: undefined;
+};
+/**
+ * Logs an Option using the provided logger (defaults to console.log).
+ * @param opt - The Option to log
+ * @param logger - The logging function to use
+ * @example
+ * logOption(42)              // logs "Some(42)"
+ * logOption(null)            // logs "None"
+ * logOption(42, console.warn) // logs "Some(42)" as warning
+ */
+export declare function logOption<T>(opt: Option<T>, logger?: Logger): void;
+/**
+ * Logs a Result using the provided logger (defaults to console.log).
+ * Logs "Ok" with the value or "Err" with the error.
+ * @param result - The Result to log
+ * @param logger - The logging function to use
+ * @example
+ * logResult(42)              // logs "Ok", 42
+ * logResult(err('fail'))     // logs "Err", "fail"
+ * logResult(42, console.warn) // logs "Ok", 42 as warning
+ */
+export declare function logResult<T, E>(result: Result<T, E>, logger?: Logger): void;
+/** Alias for inspectOption. Returns a JSON-serializable representation. */
+export declare const toJSONOption: typeof inspectOption;
+/** Alias for inspectResult. Returns a JSON-serializable representation. */
+export declare const toJSONResult: typeof inspectResult;
+export {};

package/build/devtools.js

@@ -0,0 +1,43 @@
+import { isSome, isOk } from "./types.js";
+export function formatOption(opt) {
+    return isSome(opt) ? `Some(${String(opt)})` : 'None';
+}
+export function formatResult(result) {
+    if (isOk(result)) {
+        return `Ok(${String(result)})`;
+    }
+    const error = result.error;
+    return `Err(${error instanceof Error ? error.message : String(error)})`;
+}
+export function inspectOption(opt) {
+    return isSome(opt) ? {
+        kind: 'some',
+        value: opt
+    } : {
+        kind: 'none'
+    };
+}
+export function inspectResult(result) {
+    return isOk(result) ? {
+        status: 'ok',
+        value: result
+    } : {
+        status: 'err',
+        error: result.error
+    };
+}
+export function logOption(opt, logger = console.log) {
+    logger(formatOption(opt));
+}
+export function logResult(result, logger = console.log) {
+    const tagged = inspectResult(result);
+    if (tagged.status === 'ok') {
+        logger(`Ok`, tagged.value);
+        return;
+    }
+    logger(`Err`, tagged.error);
+}
+export const toJSONOption = inspectOption;
+export const toJSONResult = inspectResult;
+
+//# sourceMappingURL=devtools.js.map

package/build/devtools.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/devtools.ts"],"sourcesContent":["import { Option, Result, isSome, isOk } from './types.js';\n\n/** Logger function signature for custom logging. */\ntype Logger = (message: string, ...args: unknown[]) => void;\n\n/**\n * Formats an Option as a human-readable string.\n * @param opt - The Option to format\n * @returns \"Some(value)\" or \"None\"\n * @example\n * formatOption(42)        // \"Some(42)\"\n * formatOption(null)      // \"None\"\n * formatOption(undefined) // \"None\"\n */\nexport function formatOption<T>(opt: Option<T>): string {\n  return isSome(opt) ? `Some(${String(opt)})` : 'None';\n}\n\n/**\n * Formats a Result as a human-readable string.\n * For Err containing an Error, displays the error message.\n * @param result - The Result to format\n * @returns \"Ok(value)\" or \"Err(error)\"\n * @example\n * formatResult(42)                      // \"Ok(42)\"\n * formatResult(err('fail'))             // \"Err(fail)\"\n * formatResult(err(new Error('oops')))  // \"Err(oops)\"\n */\nexport function formatResult<T, E>(result: Result<T, E>): string {\n  if (isOk(result)) {\n    return `Ok(${String(result)})`;\n  }\n  const error = (result as { error: E }).error;\n  return `Err(${error instanceof Error ? error.message : String(error)})`;\n}\n\n/**\n * Inspects an Option, returning a tagged object for debugging or serialization.\n * @param opt - The Option to inspect\n * @returns `{ kind: 'some', value: T }` or `{ kind: 'none' }`\n * @example\n * inspectOption(42)   // { kind: 'some', value: 42 }\n * inspectOption(null) // { kind: 'none' }\n */\nexport function inspectOption<T>(opt: Option<T>) {\n  return isSome(opt) ? { kind: 'some' as const, value: opt } : { kind: 'none' as const };\n}\n\n/**\n * Inspects a Result, returning a tagged object for debugging or serialization.\n * @param result - The Result to inspect\n * @returns `{ status: 'ok', value: T }` or `{ status: 'err', error: E }`\n * @example\n * inspectResult(42)           // { status: 'ok', value: 42 }\n * inspectResult(err('fail'))  // { status: 'err', error: 'fail' }\n */\nexport function inspectResult<T, E>(result: Result<T, E>) {\n  return isOk(result) ? { status: 'ok' as const, value: result } : { status: 'err' as const, error: (result as { error: E }).error };\n}\n\n/**\n * Logs an Option using the provided logger (defaults to console.log).\n * @param opt - The Option to log\n * @param logger - The logging function to use\n * @example\n * logOption(42)              // logs \"Some(42)\"\n * logOption(null)            // logs \"None\"\n * logOption(42, console.warn) // logs \"Some(42)\" as warning\n */\nexport function logOption<T>(opt: Option<T>, logger: Logger = console.log): void {\n  logger(formatOption(opt));\n}\n\n/**\n * Logs a Result using the provided logger (defaults to console.log).\n * Logs \"Ok\" with the value or \"Err\" with the error.\n * @param result - The Result to log\n * @param logger - The logging function to use\n * @example\n * logResult(42)              // logs \"Ok\", 42\n * logResult(err('fail'))     // logs \"Err\", \"fail\"\n * logResult(42, console.warn) // logs \"Ok\", 42 as warning\n */\nexport function logResult<T, E>(result: Result<T, E>, logger: Logger = console.log): void {\n  const tagged = inspectResult(result);\n  if (tagged.status === 'ok') {\n    logger(`Ok`, tagged.value);\n    return;\n  }\n  logger(`Err`, tagged.error);\n}\n\n/** Alias for inspectOption. Returns a JSON-serializable representation. */\nexport const toJSONOption = inspectOption;\n\n/** Alias for inspectResult. Returns a JSON-serializable representation. */\nexport const toJSONResult = inspectResult;\n"],"names":["isSome","isOk","formatOption","opt","String","formatResult","result","error","Error","message","inspectOption","kind","value","inspectResult","status","logOption","logger","console","log","logResult","tagged","toJSONOption","toJSONResult"],"mappings":"AAAA,SAAyBA,MAAM,EAAEC,IAAI,QAAQ,aAAa;AAc1D,OAAO,SAASC,aAAgBC,GAAc;IAC5C,OAAOH,OAAOG,OAAO,CAAC,KAAK,EAAEC,OAAOD,KAAK,CAAC,CAAC,GAAG;AAChD;AAYA,OAAO,SAASE,aAAmBC,MAAoB;IACrD,IAAIL,KAAKK,SAAS;QAChB,OAAO,CAAC,GAAG,EAAEF,OAAOE,QAAQ,CAAC,CAAC;IAChC;IACA,MAAMC,QAAQ,AAACD,OAAwBC,KAAK;IAC5C,OAAO,CAAC,IAAI,EAAEA,iBAAiBC,QAAQD,MAAME,OAAO,GAAGL,OAAOG,OAAO,CAAC,CAAC;AACzE;AAUA,OAAO,SAASG,cAAiBP,GAAc;IAC7C,OAAOH,OAAOG,OAAO;QAAEQ,MAAM;QAAiBC,OAAOT;IAAI,IAAI;QAAEQ,MAAM;IAAgB;AACvF;AAUA,OAAO,SAASE,cAAoBP,MAAoB;IACtD,OAAOL,KAAKK,UAAU;QAAEQ,QAAQ;QAAeF,OAAON;IAAO,IAAI;QAAEQ,QAAQ;QAAgBP,OAAO,AAACD,OAAwBC,KAAK;IAAC;AACnI;AAWA,OAAO,SAASQ,UAAaZ,GAAc,EAAEa,SAAiBC,QAAQC,GAAG;IACvEF,OAAOd,aAAaC;AACtB;AAYA,OAAO,SAASgB,UAAgBb,MAAoB,EAAEU,SAAiBC,QAAQC,GAAG;IAChF,MAAME,SAASP,cAAcP;IAC7B,IAAIc,OAAON,MAAM,KAAK,MAAM;QAC1BE,OAAO,CAAC,EAAE,CAAC,EAAEI,OAAOR,KAAK;QACzB;IACF;IACAI,OAAO,CAAC,GAAG,CAAC,EAAEI,OAAOb,KAAK;AAC5B;AAGA,OAAO,MAAMc,eAAeX,cAAc;AAG1C,OAAO,MAAMY,eAAeT,cAAc"}

package/build/index.cjs

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get Option () {
+        return _optioncjs;
+    },
+    get Result () {
+        return _resultcjs;
+    },
+    get err () {
+        return _typescjs.err;
+    },
+    get none () {
+        return _typescjs.none;
+    },
+    get ok () {
+        return _typescjs.ok;
+    },
+    get some () {
+        return _typescjs.some;
+    }
+});
+const _typescjs = require("./types.cjs");
+const _optioncjs = /*#__PURE__*/ _interop_require_wildcard(require("./option.cjs"));
+const _resultcjs = /*#__PURE__*/ _interop_require_wildcard(require("./result.cjs"));
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {
+        __proto__: null
+    };
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { some, none, ok, err } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n} from './types.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n"],"names":["Option","Result","err","none","ok","some"],"mappings":";;;;;;;;;;;QAgBYA;;;QACAC;;;QAjBaC;eAAAA,aAAG;;QAAbC;eAAAA,cAAI;;QAAEC;eAAAA,YAAE;;QAAdC;eAAAA,cAAI;;;0BAAuB;mEAgBZ;mEACA"}

package/build/index.d.ts

@@ -0,0 +1,4 @@
+export { some, none, ok, err } from './types.js';
+export type { Some, None, Ok, Err, Option as OptionType, OptionValue, IsOption, InferSome, Result as ResultType, ResultValue, ResultErrorType, IsResult, InferErr, } from './types.js';
+export * as Option from './option.js';
+export * as Result from './result.js';

package/build/index.js

@@ -0,0 +1,5 @@
+export { some, none, ok, err } from "./types.js";
+export * as Option from "./option.js";
+export * as Result from "./result.js";
+
+//# sourceMappingURL=index.js.map

package/build/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["export { some, none, ok, err } from './types.js';\nexport type {\n  Some,\n  None,\n  Ok,\n  Err,\n  Option as OptionType,\n  OptionValue,\n  IsOption,\n  InferSome,\n  Result as ResultType,\n  ResultValue,\n  ResultErrorType,\n  IsResult,\n  InferErr,\n} from './types.js';\nexport * as Option from './option.js';\nexport * as Result from './result.js';\n"],"names":["some","none","ok","err","Option","Result"],"mappings":"AAAA,SAASA,IAAI,EAAEC,IAAI,EAAEC,EAAE,EAAEC,GAAG,QAAQ,aAAa;AAgBjD,OAAO,KAAKC,MAAM,MAAM,cAAc;AACtC,OAAO,KAAKC,MAAM,MAAM,cAAc"}