nalloc 0.0.3 → 0.2.0

package/README.md

@@ -107,6 +107,40 @@ import { Option } from 'nalloc';
 Option.map(42, x => x * 2);               // value IS the Option
 ```
 
+### From oxide.ts
+
+```ts
+// oxide.ts
+import { Some, None, Ok, Err } from 'oxide.ts';
+const opt = Some(42);
+opt.map(x => x * 2);
+const result = Ok(42);
+result.mapErr(e => new Error(e));
+
+// nalloc - no wrapper objects on the happy path
+import { Option, Result, ok } from 'nalloc';
+Option.map(42, x => x * 2);              // 42 is the Option itself
+const result = ok(42);                    // zero allocation
+Result.mapErr(result, e => new Error(e));
+```
+
+### From ts-results
+
+```ts
+// ts-results
+import { Ok, Err, Some, None } from 'ts-results';
+const result = new Ok(42);
+result.map(x => x * 2);
+const opt = Some(42);
+opt.unwrapOr(0);
+
+// nalloc - same safety, zero allocations
+import { Option, Result, ok } from 'nalloc';
+const result = ok(42);                    // no wrapper
+Result.map(result, x => x * 2);
+Option.unwrapOr(42, 0);                  // value IS the Option
+```
+
 ### From Rust
 
 The API mirrors Rust's `Option` and `Result`:
@@ -350,14 +384,28 @@ Iter.tryForEach(items, item => processItem(item));
 
 ## 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 |
+| Feature | nalloc | neverthrow | fp-ts | oxide.ts | ts-results |
+|---------|---------|------------|-------|----------|------------|
+| Zero-alloc Option | Yes | No | No | No | No |
+| Zero-alloc Ok | Yes | No | No | No | No |
+| Bundle size | Tiny | Small | Large | Small | Small |
+| Learning curve | Low | Low | High | Low | Low |
+| Async support | Yes | Yes | Yes | Limited | No |
+| Tree-shakeable | Yes | Yes | Yes | Yes | Yes |
+| Iterator utilities | Yes | No | Yes | No | No |
+| safeTry (? operator) | Yes | Yes | No | No | No |
+
+## Alternatives
+
+Looking for a TypeScript Result/Option library? Here's how nalloc compares:
+
+- **neverthrow** - Popular, method-chaining API. Allocates a wrapper for every Ok and Err. nalloc avoids allocation on the happy path entirely.
+- **fp-ts / effect** - Full functional programming ecosystem with Either and Option. Powerful but heavy and steep learning curve. nalloc focuses on Result/Option with a simpler API.
+- **oxide.ts** - Rust-inspired with class-based wrappers. Every Some/Ok allocates an object. nalloc represents Some/Ok as the raw value.
+- **ts-results / ts-results-es** - Direct Rust port with class instances. Similar API surface to nalloc, but allocates on every construction.
+- **true-myth** - Result and Maybe with a functional API. Wraps all values. nalloc is a similar philosophy with zero-allocation design.
+
+nalloc is designed for codebases where allocation pressure matters - high-throughput servers, hot loops, and performance-sensitive paths - while keeping the same safety guarantees.
 
 ## License
 

package/build/iter.cjs

@@ -26,6 +26,10 @@ _export(exports, {
     }
 });
 const _typescjs = require("./types.cjs");
+const ITER_DONE = Object.freeze({
+    value: undefined,
+    done: true
+});
 function* mapWhile(source, fn) {
     for (const item of source){
         const mapped = fn(item);
@@ -41,10 +45,7 @@ function safeIter(source) {
             return this;
         },
         next () {
-            if (done) return {
-                value: undefined,
-                done: true
-            };
+            if (done) return ITER_DONE;
             try {
                 const next = iter.next();
                 if (next.done) {
@@ -70,10 +71,7 @@ function safeIter(source) {
                     iter.return?.();
                 } catch  {}
             }
-            return {
-                value: undefined,
-                done: true
-            };
+            return ITER_DONE;
         }
     };
 }

package/build/iter.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/iter.ts"],"sourcesContent":["import { isSome, isErr, err as ERR } from './types.js';\nimport type { Option, Result, Ok } from './types.js';\n\n/**\n * Yields mapped values while the mapping function returns Some, stops at the first None.\n * @param source - The iterable to map over\n * @param fn - Mapping function returning Some(value) to continue or None to stop\n * @returns Generator of mapped values\n * @example\n * [...mapWhile([1, 2, 3, 4], n => n < 3 ? some(n * 10) : none)] // [10, 20]\n */\nexport function* mapWhile<T, U>(source: Iterable<T>, fn: (value: T) => Option<U>): Generator<U> {\n  for (const item of source) {\n    const mapped = fn(item);\n    if (!isSome(mapped)) return;\n    yield mapped as U;\n  }\n}\n\n/**\n * Wraps an iterable so that each yielded value becomes Ok and any throw becomes a single Err.\n * Stops after the first error - the source's internal state is unknown after an exception.\n *\n * Uses a manual iterator instead of a generator to avoid coroutine suspend/resume overhead.\n *\n * Follows the for-of IteratorClose spec:\n * - iter.return() is never called on natural exhaustion or after a caught error\n * - iter.return() is only called on early consumer exit (break/return)\n * - Cleanup errors from iter.return() are suppressed\n *\n * @param source - The iterable to wrap\n * @returns Iterable iterator of Result values\n * @example\n * [...safeIter([1, 2, 3])]       // [Ok(1), Ok(2), Ok(3)]\n * [...safeIter(throwingIter())]   // [Ok(1), Err(error)]\n */\nexport function safeIter<T>(source: Iterable<T>): IterableIterator<Result<T, unknown>> {\n  const iter = source[Symbol.iterator]();\n  let done = false;\n  return {\n    [Symbol.iterator]() {\n      return this;\n    },\n    next(): IteratorResult<Result<T, unknown>> {\n      if (done) return { value: undefined, done: true };\n      try {\n        const next = iter.next();\n        if (next.done) {\n          done = true;\n          return next;\n        }\n        return { value: next.value as Ok<T>, done: false };\n      } catch (e) {\n        done = true;\n        return { value: ERR(e), done: false };\n      }\n    },\n    return(): IteratorResult<Result<T, unknown>> {\n      if (!done) {\n        done = true;\n        try {\n          iter.return?.();\n        } catch {\n          // suppressed\n        }\n      }\n      return { value: undefined, done: true };\n    },\n  };\n}\n\n// -- Result-oriented terminal operations --\n\n/**\n * Collects an iterable of Results into a single Result containing an array.\n * Short-circuits on the first Err.\n * @param source - Iterable of Result values\n * @returns Ok(values[]) if all Ok, or the first Err encountered\n * @example\n * tryCollect([ok(1), ok(2), ok(3)])   // Ok([1, 2, 3])\n * tryCollect([ok(1), err('x')])       // Err('x')\n */\nexport function tryCollect<T, E>(source: Iterable<Result<T, E>>): Result<T[], E> {\n  const collected: T[] = [];\n  for (const result of source) {\n    if (isErr(result)) return result;\n    collected.push(result as T);\n  }\n  return collected as Ok<T[]>;\n}\n\n/**\n * Folds an iterable with a fallible accumulator function.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to fold over\n * @param init - Initial accumulator value\n * @param fn - Folding function returning Ok(newAcc) or Err\n * @returns Ok(finalAcc) if all steps succeed, or the first Err\n * @example\n * tryFold([1, 2, 3], 0, (acc, n) => ok(acc + n))   // Ok(6)\n * tryFold([1, 2, 3], 0, (acc, n) => n === 2 ? err('stop') : ok(acc + n))  // Err('stop')\n */\nexport function tryFold<T, Acc, E>(source: Iterable<T>, init: Acc, fn: (acc: Acc, item: T) => Result<Acc, E>): Result<Acc, E> {\n  let acc = init;\n  for (const item of source) {\n    const result = fn(acc, item);\n    if (isErr(result)) return result;\n    acc = result as Acc;\n  }\n  return acc as Ok<Acc>;\n}\n\n/**\n * Iterates over a source, calling a fallible function for each item.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to iterate over\n * @param fn - Function to call for each item, returning Ok(void) or Err\n * @returns Ok(void) if all calls succeed, or the first Err\n * @example\n * tryForEach([1, 2, 3], n => ok(console.log(n)))  // Ok(void), logs 1, 2, 3\n * tryForEach([1, 2, 3], n => n === 2 ? err('stop') : ok(undefined))  // Err('stop')\n */\nexport function tryForEach<T, E>(source: Iterable<T>, fn: (item: T) => Result<void, E>): Result<void, E> {\n  for (const item of source) {\n    const result = fn(item);\n    if (isErr(result)) return result;\n  }\n  return undefined as Ok<void>;\n}\n"],"names":["mapWhile","safeIter","tryCollect","tryFold","tryForEach","source","fn","item","mapped","isSome","iter","Symbol","iterator","done","next","value","undefined","e","ERR","return","collected","result","isErr","push","init","acc"],"mappings":";;;;;;;;;;;QAWiBA;eAAAA;;QAyBDC;eAAAA;;QA8CAC;eAAAA;;QAoBAC;eAAAA;;QAoBAC;eAAAA;;;0BA1H0B;AAWnC,UAAUJ,SAAeK,MAAmB,EAAEC,EAA2B;IAC9E,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMG,SAASF,GAAGC;QAClB,IAAI,CAACE,IAAAA,gBAAM,EAACD,SAAS;QACrB,MAAMA;IACR;AACF;AAmBO,SAASP,SAAYI,MAAmB;IAC7C,MAAMK,OAAOL,MAAM,CAACM,OAAOC,QAAQ,CAAC;IACpC,IAAIC,OAAO;IACX,OAAO;QACL,CAACF,OAAOC,QAAQ,CAAC;YACf,OAAO,IAAI;QACb;QACAE;YACE,IAAID,MAAM,OAAO;gBAAEE,OAAOC;gBAAWH,MAAM;YAAK;YAChD,IAAI;gBACF,MAAMC,OAAOJ,KAAKI,IAAI;gBACtB,IAAIA,KAAKD,IAAI,EAAE;oBACbA,OAAO;oBACP,OAAOC;gBACT;gBACA,OAAO;oBAAEC,OAAOD,KAAKC,KAAK;oBAAWF,MAAM;gBAAM;YACnD,EAAE,OAAOI,GAAG;gBACVJ,OAAO;gBACP,OAAO;oBAAEE,OAAOG,IAAAA,aAAG,EAACD;oBAAIJ,MAAM;gBAAM;YACtC;QACF;QACAM;YACE,IAAI,CAACN,MAAM;gBACTA,OAAO;gBACP,IAAI;oBACFH,KAAKS,MAAM;gBACb,EAAE,OAAM,CAER;YACF;YACA,OAAO;gBAAEJ,OAAOC;gBAAWH,MAAM;YAAK;QACxC;IACF;AACF;AAaO,SAASX,WAAiBG,MAA8B;IAC7D,MAAMe,YAAiB,EAAE;IACzB,KAAK,MAAMC,UAAUhB,OAAQ;QAC3B,IAAIiB,IAAAA,eAAK,EAACD,SAAS,OAAOA;QAC1BD,UAAUG,IAAI,CAACF;IACjB;IACA,OAAOD;AACT;AAaO,SAASjB,QAAmBE,MAAmB,EAAEmB,IAAS,EAAElB,EAAyC;IAC1G,IAAImB,MAAMD;IACV,KAAK,MAAMjB,QAAQF,OAAQ;QACzB,MAAMgB,SAASf,GAAGmB,KAAKlB;QACvB,IAAIe,IAAAA,eAAK,EAACD,SAAS,OAAOA;QAC1BI,MAAMJ;IACR;IACA,OAAOI;AACT;AAYO,SAASrB,WAAiBC,MAAmB,EAAEC,EAAgC;IACpF,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMgB,SAASf,GAAGC;QAClB,IAAIe,IAAAA,eAAK,EAACD,SAAS,OAAOA;IAC5B;IACA,OAAOL;AACT"}
+{"version":3,"sources":["../src/iter.ts"],"sourcesContent":["import { isSome, isErr, err as ERR } from './types.js';\nimport type { Option, Result, Ok } from './types.js';\n\nconst ITER_DONE: IteratorResult<never> = Object.freeze({ value: undefined as never, done: true as const });\n\n/**\n * Yields mapped values while the mapping function returns Some, stops at the first None.\n * @param source - The iterable to map over\n * @param fn - Mapping function returning Some(value) to continue or None to stop\n * @returns Generator of mapped values\n * @example\n * [...mapWhile([1, 2, 3, 4], n => n < 3 ? some(n * 10) : none)] // [10, 20]\n */\nexport function* mapWhile<T, U>(source: Iterable<T>, fn: (value: T) => Option<U>): Generator<U> {\n  for (const item of source) {\n    const mapped = fn(item);\n    if (!isSome(mapped)) return;\n    yield mapped as U;\n  }\n}\n\n/**\n * Wraps an iterable so that each yielded value becomes Ok and any throw becomes a single Err.\n * Stops after the first error - the source's internal state is unknown after an exception.\n *\n * Uses a manual iterator instead of a generator to avoid coroutine suspend/resume overhead.\n *\n * Follows the for-of IteratorClose spec:\n * - iter.return() is never called on natural exhaustion or after a caught error\n * - iter.return() is only called on early consumer exit (break/return)\n * - Cleanup errors from iter.return() are suppressed\n *\n * @param source - The iterable to wrap\n * @returns Iterable iterator of Result values\n * @example\n * [...safeIter([1, 2, 3])]       // [Ok(1), Ok(2), Ok(3)]\n * [...safeIter(throwingIter())]   // [Ok(1), Err(error)]\n */\nexport function safeIter<T>(source: Iterable<T>): IterableIterator<Result<T, unknown>> {\n  const iter = source[Symbol.iterator]();\n  let done = false;\n  return {\n    [Symbol.iterator]() {\n      return this;\n    },\n    next(): IteratorResult<Result<T, unknown>> {\n      if (done) return ITER_DONE;\n      try {\n        const next = iter.next();\n        if (next.done) {\n          done = true;\n          return next;\n        }\n        return { value: next.value as Ok<T>, done: false };\n      } catch (e) {\n        done = true;\n        return { value: ERR(e), done: false };\n      }\n    },\n    return(): IteratorResult<Result<T, unknown>> {\n      if (!done) {\n        done = true;\n        try {\n          iter.return?.();\n        } catch {\n          // suppressed\n        }\n      }\n      return ITER_DONE;\n    },\n  };\n}\n\n// -- Result-oriented terminal operations --\n\n/**\n * Collects an iterable of Results into a single Result containing an array.\n * Short-circuits on the first Err.\n * @param source - Iterable of Result values\n * @returns Ok(values[]) if all Ok, or the first Err encountered\n * @example\n * tryCollect([ok(1), ok(2), ok(3)])   // Ok([1, 2, 3])\n * tryCollect([ok(1), err('x')])       // Err('x')\n */\nexport function tryCollect<T, E>(source: Iterable<Result<T, E>>): Result<T[], E> {\n  const collected: T[] = [];\n  for (const result of source) {\n    if (isErr(result)) return result;\n    collected.push(result as T);\n  }\n  return collected as Ok<T[]>;\n}\n\n/**\n * Folds an iterable with a fallible accumulator function.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to fold over\n * @param init - Initial accumulator value\n * @param fn - Folding function returning Ok(newAcc) or Err\n * @returns Ok(finalAcc) if all steps succeed, or the first Err\n * @example\n * tryFold([1, 2, 3], 0, (acc, n) => ok(acc + n))   // Ok(6)\n * tryFold([1, 2, 3], 0, (acc, n) => n === 2 ? err('stop') : ok(acc + n))  // Err('stop')\n */\nexport function tryFold<T, Acc, E>(source: Iterable<T>, init: Acc, fn: (acc: Acc, item: T) => Result<Acc, E>): Result<Acc, E> {\n  let acc = init;\n  for (const item of source) {\n    const result = fn(acc, item);\n    if (isErr(result)) return result;\n    acc = result as Acc;\n  }\n  return acc as Ok<Acc>;\n}\n\n/**\n * Iterates over a source, calling a fallible function for each item.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to iterate over\n * @param fn - Function to call for each item, returning Ok(void) or Err\n * @returns Ok(void) if all calls succeed, or the first Err\n * @example\n * tryForEach([1, 2, 3], n => ok(console.log(n)))  // Ok(void), logs 1, 2, 3\n * tryForEach([1, 2, 3], n => n === 2 ? err('stop') : ok(undefined))  // Err('stop')\n */\nexport function tryForEach<T, E>(source: Iterable<T>, fn: (item: T) => Result<void, E>): Result<void, E> {\n  for (const item of source) {\n    const result = fn(item);\n    if (isErr(result)) return result;\n  }\n  return undefined as Ok<void>;\n}\n"],"names":["mapWhile","safeIter","tryCollect","tryFold","tryForEach","ITER_DONE","Object","freeze","value","undefined","done","source","fn","item","mapped","isSome","iter","Symbol","iterator","next","e","ERR","return","collected","result","isErr","push","init","acc"],"mappings":";;;;;;;;;;;QAaiBA;eAAAA;;QAyBDC;eAAAA;;QA8CAC;eAAAA;;QAoBAC;eAAAA;;QAoBAC;eAAAA;;;0BA5H0B;AAG1C,MAAMC,YAAmCC,OAAOC,MAAM,CAAC;IAAEC,OAAOC;IAAoBC,MAAM;AAAc;AAUjG,UAAUV,SAAeW,MAAmB,EAAEC,EAA2B;IAC9E,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMG,SAASF,GAAGC;QAClB,IAAI,CAACE,IAAAA,gBAAM,EAACD,SAAS;QACrB,MAAMA;IACR;AACF;AAmBO,SAASb,SAAYU,MAAmB;IAC7C,MAAMK,OAAOL,MAAM,CAACM,OAAOC,QAAQ,CAAC;IACpC,IAAIR,OAAO;IACX,OAAO;QACL,CAACO,OAAOC,QAAQ,CAAC;YACf,OAAO,IAAI;QACb;QACAC;YACE,IAAIT,MAAM,OAAOL;YACjB,IAAI;gBACF,MAAMc,OAAOH,KAAKG,IAAI;gBACtB,IAAIA,KAAKT,IAAI,EAAE;oBACbA,OAAO;oBACP,OAAOS;gBACT;gBACA,OAAO;oBAAEX,OAAOW,KAAKX,KAAK;oBAAWE,MAAM;gBAAM;YACnD,EAAE,OAAOU,GAAG;gBACVV,OAAO;gBACP,OAAO;oBAAEF,OAAOa,IAAAA,aAAG,EAACD;oBAAIV,MAAM;gBAAM;YACtC;QACF;QACAY;YACE,IAAI,CAACZ,MAAM;gBACTA,OAAO;gBACP,IAAI;oBACFM,KAAKM,MAAM;gBACb,EAAE,OAAM,CAER;YACF;YACA,OAAOjB;QACT;IACF;AACF;AAaO,SAASH,WAAiBS,MAA8B;IAC7D,MAAMY,YAAiB,EAAE;IACzB,KAAK,MAAMC,UAAUb,OAAQ;QAC3B,IAAIc,IAAAA,eAAK,EAACD,SAAS,OAAOA;QAC1BD,UAAUG,IAAI,CAACF;IACjB;IACA,OAAOD;AACT;AAaO,SAASpB,QAAmBQ,MAAmB,EAAEgB,IAAS,EAAEf,EAAyC;IAC1G,IAAIgB,MAAMD;IACV,KAAK,MAAMd,QAAQF,OAAQ;QACzB,MAAMa,SAASZ,GAAGgB,KAAKf;QACvB,IAAIY,IAAAA,eAAK,EAACD,SAAS,OAAOA;QAC1BI,MAAMJ;IACR;IACA,OAAOI;AACT;AAYO,SAASxB,WAAiBO,MAAmB,EAAEC,EAAgC;IACpF,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMa,SAASZ,GAAGC;QAClB,IAAIY,IAAAA,eAAK,EAACD,SAAS,OAAOA;IAC5B;IACA,OAAOf;AACT"}

package/build/iter.js

@@ -1,4 +1,8 @@
 import { isSome, isErr, err as ERR } from "./types.js";
+const ITER_DONE = Object.freeze({
+    value: undefined,
+    done: true
+});
 export function* mapWhile(source, fn) {
     for (const item of source){
         const mapped = fn(item);
@@ -14,10 +18,7 @@ export function safeIter(source) {
             return this;
         },
         next () {
-            if (done) return {
-                value: undefined,
-                done: true
-            };
+            if (done) return ITER_DONE;
             try {
                 const next = iter.next();
                 if (next.done) {
@@ -43,10 +44,7 @@ export function safeIter(source) {
                     iter.return?.();
                 } catch  {}
             }
-            return {
-                value: undefined,
-                done: true
-            };
+            return ITER_DONE;
         }
     };
 }

package/build/iter.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/iter.ts"],"sourcesContent":["import { isSome, isErr, err as ERR } from './types.js';\nimport type { Option, Result, Ok } from './types.js';\n\n/**\n * Yields mapped values while the mapping function returns Some, stops at the first None.\n * @param source - The iterable to map over\n * @param fn - Mapping function returning Some(value) to continue or None to stop\n * @returns Generator of mapped values\n * @example\n * [...mapWhile([1, 2, 3, 4], n => n < 3 ? some(n * 10) : none)] // [10, 20]\n */\nexport function* mapWhile<T, U>(source: Iterable<T>, fn: (value: T) => Option<U>): Generator<U> {\n  for (const item of source) {\n    const mapped = fn(item);\n    if (!isSome(mapped)) return;\n    yield mapped as U;\n  }\n}\n\n/**\n * Wraps an iterable so that each yielded value becomes Ok and any throw becomes a single Err.\n * Stops after the first error - the source's internal state is unknown after an exception.\n *\n * Uses a manual iterator instead of a generator to avoid coroutine suspend/resume overhead.\n *\n * Follows the for-of IteratorClose spec:\n * - iter.return() is never called on natural exhaustion or after a caught error\n * - iter.return() is only called on early consumer exit (break/return)\n * - Cleanup errors from iter.return() are suppressed\n *\n * @param source - The iterable to wrap\n * @returns Iterable iterator of Result values\n * @example\n * [...safeIter([1, 2, 3])]       // [Ok(1), Ok(2), Ok(3)]\n * [...safeIter(throwingIter())]   // [Ok(1), Err(error)]\n */\nexport function safeIter<T>(source: Iterable<T>): IterableIterator<Result<T, unknown>> {\n  const iter = source[Symbol.iterator]();\n  let done = false;\n  return {\n    [Symbol.iterator]() {\n      return this;\n    },\n    next(): IteratorResult<Result<T, unknown>> {\n      if (done) return { value: undefined, done: true };\n      try {\n        const next = iter.next();\n        if (next.done) {\n          done = true;\n          return next;\n        }\n        return { value: next.value as Ok<T>, done: false };\n      } catch (e) {\n        done = true;\n        return { value: ERR(e), done: false };\n      }\n    },\n    return(): IteratorResult<Result<T, unknown>> {\n      if (!done) {\n        done = true;\n        try {\n          iter.return?.();\n        } catch {\n          // suppressed\n        }\n      }\n      return { value: undefined, done: true };\n    },\n  };\n}\n\n// -- Result-oriented terminal operations --\n\n/**\n * Collects an iterable of Results into a single Result containing an array.\n * Short-circuits on the first Err.\n * @param source - Iterable of Result values\n * @returns Ok(values[]) if all Ok, or the first Err encountered\n * @example\n * tryCollect([ok(1), ok(2), ok(3)])   // Ok([1, 2, 3])\n * tryCollect([ok(1), err('x')])       // Err('x')\n */\nexport function tryCollect<T, E>(source: Iterable<Result<T, E>>): Result<T[], E> {\n  const collected: T[] = [];\n  for (const result of source) {\n    if (isErr(result)) return result;\n    collected.push(result as T);\n  }\n  return collected as Ok<T[]>;\n}\n\n/**\n * Folds an iterable with a fallible accumulator function.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to fold over\n * @param init - Initial accumulator value\n * @param fn - Folding function returning Ok(newAcc) or Err\n * @returns Ok(finalAcc) if all steps succeed, or the first Err\n * @example\n * tryFold([1, 2, 3], 0, (acc, n) => ok(acc + n))   // Ok(6)\n * tryFold([1, 2, 3], 0, (acc, n) => n === 2 ? err('stop') : ok(acc + n))  // Err('stop')\n */\nexport function tryFold<T, Acc, E>(source: Iterable<T>, init: Acc, fn: (acc: Acc, item: T) => Result<Acc, E>): Result<Acc, E> {\n  let acc = init;\n  for (const item of source) {\n    const result = fn(acc, item);\n    if (isErr(result)) return result;\n    acc = result as Acc;\n  }\n  return acc as Ok<Acc>;\n}\n\n/**\n * Iterates over a source, calling a fallible function for each item.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to iterate over\n * @param fn - Function to call for each item, returning Ok(void) or Err\n * @returns Ok(void) if all calls succeed, or the first Err\n * @example\n * tryForEach([1, 2, 3], n => ok(console.log(n)))  // Ok(void), logs 1, 2, 3\n * tryForEach([1, 2, 3], n => n === 2 ? err('stop') : ok(undefined))  // Err('stop')\n */\nexport function tryForEach<T, E>(source: Iterable<T>, fn: (item: T) => Result<void, E>): Result<void, E> {\n  for (const item of source) {\n    const result = fn(item);\n    if (isErr(result)) return result;\n  }\n  return undefined as Ok<void>;\n}\n"],"names":["isSome","isErr","err","ERR","mapWhile","source","fn","item","mapped","safeIter","iter","Symbol","iterator","done","next","value","undefined","e","return","tryCollect","collected","result","push","tryFold","init","acc","tryForEach"],"mappings":"AAAA,SAASA,MAAM,EAAEC,KAAK,EAAEC,OAAOC,GAAG,QAAQ,aAAa;AAWvD,OAAO,UAAUC,SAAeC,MAAmB,EAAEC,EAA2B;IAC9E,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMG,SAASF,GAAGC;QAClB,IAAI,CAACP,OAAOQ,SAAS;QACrB,MAAMA;IACR;AACF;AAmBA,OAAO,SAASC,SAAYJ,MAAmB;IAC7C,MAAMK,OAAOL,MAAM,CAACM,OAAOC,QAAQ,CAAC;IACpC,IAAIC,OAAO;IACX,OAAO;QACL,CAACF,OAAOC,QAAQ,CAAC;YACf,OAAO,IAAI;QACb;QACAE;YACE,IAAID,MAAM,OAAO;gBAAEE,OAAOC;gBAAWH,MAAM;YAAK;YAChD,IAAI;gBACF,MAAMC,OAAOJ,KAAKI,IAAI;gBACtB,IAAIA,KAAKD,IAAI,EAAE;oBACbA,OAAO;oBACP,OAAOC;gBACT;gBACA,OAAO;oBAAEC,OAAOD,KAAKC,KAAK;oBAAWF,MAAM;gBAAM;YACnD,EAAE,OAAOI,GAAG;gBACVJ,OAAO;gBACP,OAAO;oBAAEE,OAAOZ,IAAIc;oBAAIJ,MAAM;gBAAM;YACtC;QACF;QACAK;YACE,IAAI,CAACL,MAAM;gBACTA,OAAO;gBACP,IAAI;oBACFH,KAAKQ,MAAM;gBACb,EAAE,OAAM,CAER;YACF;YACA,OAAO;gBAAEH,OAAOC;gBAAWH,MAAM;YAAK;QACxC;IACF;AACF;AAaA,OAAO,SAASM,WAAiBd,MAA8B;IAC7D,MAAMe,YAAiB,EAAE;IACzB,KAAK,MAAMC,UAAUhB,OAAQ;QAC3B,IAAIJ,MAAMoB,SAAS,OAAOA;QAC1BD,UAAUE,IAAI,CAACD;IACjB;IACA,OAAOD;AACT;AAaA,OAAO,SAASG,QAAmBlB,MAAmB,EAAEmB,IAAS,EAAElB,EAAyC;IAC1G,IAAImB,MAAMD;IACV,KAAK,MAAMjB,QAAQF,OAAQ;QACzB,MAAMgB,SAASf,GAAGmB,KAAKlB;QACvB,IAAIN,MAAMoB,SAAS,OAAOA;QAC1BI,MAAMJ;IACR;IACA,OAAOI;AACT;AAYA,OAAO,SAASC,WAAiBrB,MAAmB,EAAEC,EAAgC;IACpF,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMgB,SAASf,GAAGC;QAClB,IAAIN,MAAMoB,SAAS,OAAOA;IAC5B;IACA,OAAOL;AACT"}
+{"version":3,"sources":["../src/iter.ts"],"sourcesContent":["import { isSome, isErr, err as ERR } from './types.js';\nimport type { Option, Result, Ok } from './types.js';\n\nconst ITER_DONE: IteratorResult<never> = Object.freeze({ value: undefined as never, done: true as const });\n\n/**\n * Yields mapped values while the mapping function returns Some, stops at the first None.\n * @param source - The iterable to map over\n * @param fn - Mapping function returning Some(value) to continue or None to stop\n * @returns Generator of mapped values\n * @example\n * [...mapWhile([1, 2, 3, 4], n => n < 3 ? some(n * 10) : none)] // [10, 20]\n */\nexport function* mapWhile<T, U>(source: Iterable<T>, fn: (value: T) => Option<U>): Generator<U> {\n  for (const item of source) {\n    const mapped = fn(item);\n    if (!isSome(mapped)) return;\n    yield mapped as U;\n  }\n}\n\n/**\n * Wraps an iterable so that each yielded value becomes Ok and any throw becomes a single Err.\n * Stops after the first error - the source's internal state is unknown after an exception.\n *\n * Uses a manual iterator instead of a generator to avoid coroutine suspend/resume overhead.\n *\n * Follows the for-of IteratorClose spec:\n * - iter.return() is never called on natural exhaustion or after a caught error\n * - iter.return() is only called on early consumer exit (break/return)\n * - Cleanup errors from iter.return() are suppressed\n *\n * @param source - The iterable to wrap\n * @returns Iterable iterator of Result values\n * @example\n * [...safeIter([1, 2, 3])]       // [Ok(1), Ok(2), Ok(3)]\n * [...safeIter(throwingIter())]   // [Ok(1), Err(error)]\n */\nexport function safeIter<T>(source: Iterable<T>): IterableIterator<Result<T, unknown>> {\n  const iter = source[Symbol.iterator]();\n  let done = false;\n  return {\n    [Symbol.iterator]() {\n      return this;\n    },\n    next(): IteratorResult<Result<T, unknown>> {\n      if (done) return ITER_DONE;\n      try {\n        const next = iter.next();\n        if (next.done) {\n          done = true;\n          return next;\n        }\n        return { value: next.value as Ok<T>, done: false };\n      } catch (e) {\n        done = true;\n        return { value: ERR(e), done: false };\n      }\n    },\n    return(): IteratorResult<Result<T, unknown>> {\n      if (!done) {\n        done = true;\n        try {\n          iter.return?.();\n        } catch {\n          // suppressed\n        }\n      }\n      return ITER_DONE;\n    },\n  };\n}\n\n// -- Result-oriented terminal operations --\n\n/**\n * Collects an iterable of Results into a single Result containing an array.\n * Short-circuits on the first Err.\n * @param source - Iterable of Result values\n * @returns Ok(values[]) if all Ok, or the first Err encountered\n * @example\n * tryCollect([ok(1), ok(2), ok(3)])   // Ok([1, 2, 3])\n * tryCollect([ok(1), err('x')])       // Err('x')\n */\nexport function tryCollect<T, E>(source: Iterable<Result<T, E>>): Result<T[], E> {\n  const collected: T[] = [];\n  for (const result of source) {\n    if (isErr(result)) return result;\n    collected.push(result as T);\n  }\n  return collected as Ok<T[]>;\n}\n\n/**\n * Folds an iterable with a fallible accumulator function.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to fold over\n * @param init - Initial accumulator value\n * @param fn - Folding function returning Ok(newAcc) or Err\n * @returns Ok(finalAcc) if all steps succeed, or the first Err\n * @example\n * tryFold([1, 2, 3], 0, (acc, n) => ok(acc + n))   // Ok(6)\n * tryFold([1, 2, 3], 0, (acc, n) => n === 2 ? err('stop') : ok(acc + n))  // Err('stop')\n */\nexport function tryFold<T, Acc, E>(source: Iterable<T>, init: Acc, fn: (acc: Acc, item: T) => Result<Acc, E>): Result<Acc, E> {\n  let acc = init;\n  for (const item of source) {\n    const result = fn(acc, item);\n    if (isErr(result)) return result;\n    acc = result as Acc;\n  }\n  return acc as Ok<Acc>;\n}\n\n/**\n * Iterates over a source, calling a fallible function for each item.\n * Short-circuits on the first Err returned by fn.\n * @param source - The iterable to iterate over\n * @param fn - Function to call for each item, returning Ok(void) or Err\n * @returns Ok(void) if all calls succeed, or the first Err\n * @example\n * tryForEach([1, 2, 3], n => ok(console.log(n)))  // Ok(void), logs 1, 2, 3\n * tryForEach([1, 2, 3], n => n === 2 ? err('stop') : ok(undefined))  // Err('stop')\n */\nexport function tryForEach<T, E>(source: Iterable<T>, fn: (item: T) => Result<void, E>): Result<void, E> {\n  for (const item of source) {\n    const result = fn(item);\n    if (isErr(result)) return result;\n  }\n  return undefined as Ok<void>;\n}\n"],"names":["isSome","isErr","err","ERR","ITER_DONE","Object","freeze","value","undefined","done","mapWhile","source","fn","item","mapped","safeIter","iter","Symbol","iterator","next","e","return","tryCollect","collected","result","push","tryFold","init","acc","tryForEach"],"mappings":"AAAA,SAASA,MAAM,EAAEC,KAAK,EAAEC,OAAOC,GAAG,QAAQ,aAAa;AAGvD,MAAMC,YAAmCC,OAAOC,MAAM,CAAC;IAAEC,OAAOC;IAAoBC,MAAM;AAAc;AAUxG,OAAO,UAAUC,SAAeC,MAAmB,EAAEC,EAA2B;IAC9E,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMG,SAASF,GAAGC;QAClB,IAAI,CAACb,OAAOc,SAAS;QACrB,MAAMA;IACR;AACF;AAmBA,OAAO,SAASC,SAAYJ,MAAmB;IAC7C,MAAMK,OAAOL,MAAM,CAACM,OAAOC,QAAQ,CAAC;IACpC,IAAIT,OAAO;IACX,OAAO;QACL,CAACQ,OAAOC,QAAQ,CAAC;YACf,OAAO,IAAI;QACb;QACAC;YACE,IAAIV,MAAM,OAAOL;YACjB,IAAI;gBACF,MAAMe,OAAOH,KAAKG,IAAI;gBACtB,IAAIA,KAAKV,IAAI,EAAE;oBACbA,OAAO;oBACP,OAAOU;gBACT;gBACA,OAAO;oBAAEZ,OAAOY,KAAKZ,KAAK;oBAAWE,MAAM;gBAAM;YACnD,EAAE,OAAOW,GAAG;gBACVX,OAAO;gBACP,OAAO;oBAAEF,OAAOJ,IAAIiB;oBAAIX,MAAM;gBAAM;YACtC;QACF;QACAY;YACE,IAAI,CAACZ,MAAM;gBACTA,OAAO;gBACP,IAAI;oBACFO,KAAKK,MAAM;gBACb,EAAE,OAAM,CAER;YACF;YACA,OAAOjB;QACT;IACF;AACF;AAaA,OAAO,SAASkB,WAAiBX,MAA8B;IAC7D,MAAMY,YAAiB,EAAE;IACzB,KAAK,MAAMC,UAAUb,OAAQ;QAC3B,IAAIV,MAAMuB,SAAS,OAAOA;QAC1BD,UAAUE,IAAI,CAACD;IACjB;IACA,OAAOD;AACT;AAaA,OAAO,SAASG,QAAmBf,MAAmB,EAAEgB,IAAS,EAAEf,EAAyC;IAC1G,IAAIgB,MAAMD;IACV,KAAK,MAAMd,QAAQF,OAAQ;QACzB,MAAMa,SAASZ,GAAGgB,KAAKf;QACvB,IAAIZ,MAAMuB,SAAS,OAAOA;QAC1BI,MAAMJ;IACR;IACA,OAAOI;AACT;AAYA,OAAO,SAASC,WAAiBlB,MAAmB,EAAEC,EAAgC;IACpF,KAAK,MAAMC,QAAQF,OAAQ;QACzB,MAAMa,SAASZ,GAAGC;QAClB,IAAIZ,MAAMuB,SAAS,OAAOA;IAC5B;IACA,OAAOhB;AACT"}

package/build/option.cjs

@@ -96,6 +96,9 @@ _export(exports, {
     get tap () {
         return tap;
     },
+    get tapNone () {
+        return tapNone;
+    },
     get toArray () {
         return toArray;
     },
@@ -128,6 +131,10 @@ _export(exports, {
     }
 });
 const _typescjs = require("./types.cjs");
+const NONE_PAIR = Object.freeze([
+    _typescjs.NONE,
+    _typescjs.NONE
+]);
 function fromNullable(value) {
     return (0, _typescjs.optionOf)(value);
 }
@@ -174,15 +181,19 @@ function map(opt, fn) {
 function flatMap(opt, fn) {
     return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : fn(opt);
 }
-function andThen(opt, fn) {
-    return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : fn(opt);
-}
+const andThen = flatMap;
 function tap(opt, fn) {
     if ((0, _typescjs.isSome)(opt)) {
         fn(opt);
     }
     return opt;
 }
+function tapNone(opt, fn) {
+    if ((0, _typescjs.isNone)(opt)) {
+        fn();
+    }
+    return opt;
+}
 function isNoneOr(opt, predicate) {
     return (0, _typescjs.isNone)(opt) || predicate(opt);
 }
@@ -229,10 +240,7 @@ function zip(opt, other) {
     ] : _typescjs.NONE;
 }
 function unzip(opt) {
-    if ((0, _typescjs.isNone)(opt)) return [
-        _typescjs.NONE,
-        _typescjs.NONE
-    ];
+    if ((0, _typescjs.isNone)(opt)) return NONE_PAIR;
     const [a, b] = opt;
     return [
         (0, _typescjs.optionOf)(a),
@@ -249,7 +257,7 @@ function flatten(opt) {
     return (0, _typescjs.isNone)(opt) ? _typescjs.NONE : opt;
 }
 function contains(opt, value) {
-    return (0, _typescjs.isSome)(opt) && opt === value;
+    return (0, _typescjs.isSome)(opt) && (opt === value || opt !== opt && value !== value);
 }
 function isSomeAnd(opt, predicate) {
     return (0, _typescjs.isSome)(opt) && predicate(opt);

package/build/option.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return [NONE, NONE];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && opt === value;\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["and","andThen","assertSome","contains","expect","filter","filterMap","findMap","flatMap","flatten","fromNullable","fromPromise","isNone","isNoneOr","isSome","isSomeAnd","map","mapOr","mapOrElse","match","of","ofErr","ofOk","okOr","okOrElse","or","orElse","satisfiesOption","tap","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","value","promise","onRejected","error","NONE","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","a","b","other","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":"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"}
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\nconst NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Executes a side effect if None, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tapNone(none, () => console.log('missing')) // logs 'missing', returns None\n */\nexport function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;\nexport function tapNone(opt: None, fn: () => void): None;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {\n  if (isNone(opt)) {\n    fn();\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && (opt === value || (opt !== opt && value !== value));\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["and","andThen","assertSome","contains","expect","filter","filterMap","findMap","flatMap","flatten","fromNullable","fromPromise","isNone","isNoneOr","isSome","isSomeAnd","map","mapOr","mapOrElse","match","of","ofErr","ofOk","okOr","okOrElse","or","orElse","satisfiesOption","tap","tapNone","toArray","toNullable","toUndefined","unwrap","unwrapOr","unwrapOrElse","unwrapOrReturn","unzip","xor","zip","NONE_PAIR","Object","freeze","NONE","value","promise","onRejected","error","opt","onNone","message","Error","_","values","fn","collected","mapped","push","result","undefined","predicate","defaultValue","optb","a","b","other","defaultFn","EMPTY","onSome","err","isOk","isErr"],"mappings":"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"}

package/build/option.d.ts

@@ -105,8 +105,7 @@ export declare function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U
  * @param fn - Function returning an Option
  * @returns The result of fn(value) if Some, None otherwise
  */
-export declare function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;
-export declare function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;
+export declare const andThen: typeof flatMap;
 /**
  * Executes a side effect if Some, then returns the original Option.
  * @param opt - The Option to tap
@@ -118,6 +117,17 @@ export declare function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U
 export declare function tap<T>(opt: None, fn: (value: T) => void): None;
 export declare function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;
 export declare function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;
+/**
+ * Executes a side effect if None, then returns the original Option.
+ * @param opt - The Option to tap
+ * @param fn - Side effect function
+ * @returns The original Option unchanged
+ * @example
+ * tapNone(none, () => console.log('missing')) // logs 'missing', returns None
+ */
+export declare function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;
+export declare function tapNone(opt: None, fn: () => void): None;
+export declare function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;
 /**
  * Returns true if None, or if Some and predicate returns true.
  * @param opt - The Option to check

package/build/option.js

@@ -1,5 +1,9 @@
 import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from "./types.js";
 export { isSome, isNone, of };
+const NONE_PAIR = Object.freeze([
+    NONE,
+    NONE
+]);
 export function fromNullable(value) {
     return of(value);
 }
@@ -46,15 +50,19 @@ export function map(opt, fn) {
 export function flatMap(opt, fn) {
     return isNone(opt) ? NONE : fn(opt);
 }
-export function andThen(opt, fn) {
-    return isNone(opt) ? NONE : fn(opt);
-}
+export const andThen = flatMap;
 export function tap(opt, fn) {
     if (isSome(opt)) {
         fn(opt);
     }
     return opt;
 }
+export function tapNone(opt, fn) {
+    if (isNone(opt)) {
+        fn();
+    }
+    return opt;
+}
 export function isNoneOr(opt, predicate) {
     return isNone(opt) || predicate(opt);
 }
@@ -101,10 +109,7 @@ export function zip(opt, other) {
     ] : NONE;
 }
 export function unzip(opt) {
-    if (isNone(opt)) return [
-        NONE,
-        NONE
-    ];
+    if (isNone(opt)) return NONE_PAIR;
     const [a, b] = opt;
     return [
         of(a),
@@ -121,7 +126,7 @@ export function flatten(opt) {
     return isNone(opt) ? NONE : opt;
 }
 export function contains(opt, value) {
-    return isSome(opt) && opt === value;
+    return isSome(opt) && (opt === value || opt !== opt && value !== value);
 }
 export function isSomeAnd(opt, predicate) {
     return isSome(opt) && predicate(opt);

package/build/option.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport function andThen<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function andThen<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return [NONE, NONE];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && opt === value;\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["NONE","EMPTY","isSome","isNone","optionOf","of","err","isOk","isErr","fromNullable","value","fromPromise","promise","onRejected","error","unwrapOrReturn","opt","onNone","assertSome","message","Error","satisfiesOption","_","filterMap","values","fn","collected","mapped","push","findMap","map","result","undefined","flatMap","andThen","tap","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","a","b","and","zip","other","unzip","mapOr","mapOrElse","defaultFn","flatten","contains","isSomeAnd","toArray","toNullable","toUndefined","match","onSome","okOr","okOrElse","ofOk","ofErr"],"mappings":"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"}
+{"version":3,"sources":["../src/option.ts"],"sourcesContent":["import { NONE, EMPTY, isSome, isNone, optionOf as of, err, isOk, isErr } from './types.js';\nimport type { Some, None, Option, NoneValueType, ValueType, Result, Ok, Widen } from './types.js';\n\nexport type { Some, None, Option };\nexport { isSome, isNone, of };\n\nconst NONE_PAIR: readonly [None, None] = Object.freeze([NONE, NONE]);\n\n/**\n * Creates an Option from a nullable value with widened types.\n * @param value - The value to wrap\n * @returns Some(value) if non-null, None otherwise\n * @example\n * fromNullable(42)   // Some(42) with type Option<number>\n * fromNullable(null) // None\n */\nexport function fromNullable(value: null): None;\nexport function fromNullable(value: undefined): None;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>>;\nexport function fromNullable<T>(value: T | NoneValueType): Option<Widen<T>> {\n  return of(value) as Option<Widen<T>>;\n}\n\n/**\n * Creates an Option from a Promise. Resolves to Some if successful, None on rejection.\n * @param promise - The promise to convert\n * @param onRejected - Optional handler for rejected promises\n * @returns Promise resolving to Some(value) or None\n * @example\n * await fromPromise(Promise.resolve(42))     // Some(42)\n * await fromPromise(Promise.reject('error')) // None\n */\nexport async function fromPromise<T>(promise: Promise<T | NoneValueType>, onRejected?: (error: unknown) => T | NoneValueType): Promise<Option<T>> {\n  try {\n    const value = await promise;\n    return of(value as T);\n  } catch (error) {\n    if (!onRejected) {\n      return NONE;\n    }\n    return of(onRejected(error));\n  }\n}\n\n/**\n * Unwraps an Option or returns a computed value if None.\n * @param opt - The Option to unwrap\n * @param onNone - Function called if opt is None\n * @returns The value if Some, or the result of onNone()\n * @example\n * unwrapOrReturn(some(42), () => 0)  // 42\n * unwrapOrReturn(none, () => 0)      // 0\n */\nexport function unwrapOrReturn<T, R>(opt: Option<T>, onNone: () => R): Widen<T> | R {\n  return isSome(opt) ? (opt as Widen<T>) : onNone();\n}\n\n/**\n * Asserts that an Option is Some, throwing if None.\n * @param opt - The Option to assert\n * @param message - Custom error message\n * @throws Error if opt is None\n * @example\n * assertSome(some(42))  // passes\n * assertSome(none)      // throws Error\n */\nexport function assertSome<T>(opt: Option<T>, message?: string): asserts opt is Some<ValueType<T>> {\n  if (isNone(opt)) {\n    throw new Error(message ?? 'Expected Option to contain a value');\n  }\n}\n\n/**\n * Compile-time type assertion helper to satisfy Option type constraints.\n *\n * WARNING: This function performs NO runtime validation. It is a no-op at\n * runtime to preserve zero-allocation semantics. Use assertSome() if you\n * need runtime validation that a value is Some.\n *\n * @param _ - The value to assert as Option (not validated at runtime)\n * @example\n * const value: number | null = getValue();\n * satisfiesOption(value); // Compiles, but no runtime check\n * // value is now typed as Option<number>\n */\nexport function satisfiesOption<T>(_: Option<T> | T): asserts _ is Option<T> {\n  // Compile-time only - no runtime validation to preserve zero-allocation semantics.\n}\n\n/**\n * Maps and filters an iterable, collecting only Some values.\n * @param values - The iterable to process\n * @param fn - Function that returns Option for each value\n * @returns Array of unwrapped Some values\n * @example\n * filterMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // [4, 6]\n */\nexport function filterMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): U[] {\n  const collected: U[] = [];\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) collected.push(mapped);\n  }\n  return collected;\n}\n\n/**\n * Finds the first element that maps to Some, returning that value.\n * @param values - Iterable to search\n * @param fn - Function that returns Some for matches\n * @returns The first Some value, or None if no match\n * @example\n * findMap([1, 2, 3], n => n > 1 ? some(n * 2) : none) // Some(4)\n * findMap([1], n => n > 5 ? some(n) : none)           // None\n */\nexport function findMap<T, U>(values: Iterable<T>, fn: (value: T) => Option<U>): Option<U> {\n  for (const value of values) {\n    const mapped = fn(value);\n    if (isSome(mapped)) return mapped;\n  }\n  return NONE;\n}\n\n/**\n * Transforms the value inside a Some, or returns None.\n * @param opt - The Option to map\n * @param fn - Transform function\n * @returns Some(fn(value)) if Some, None otherwise\n * @example\n * map(some(2), x => x * 2) // Some(4)\n * map(none, x => x * 2)    // None\n */\nexport function map<T, U>(opt: None, fn: (value: T) => U): None;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U>;\nexport function map<T, U>(opt: Option<T>, fn: (value: T) => U | NoneValueType): Option<U> {\n  if (isNone(opt)) return NONE;\n  const result = fn(opt);\n  return result === null || result === undefined ? NONE : (result as Some<ValueType<U>>);\n}\n\n/**\n * Chains Option-returning functions. Returns None if the input is None.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n * @example\n * flatMap(some(2), x => some(x * 2)) // Some(4)\n * flatMap(some(2), x => none)        // None\n * flatMap(none, x => some(x * 2))    // None\n */\nexport function flatMap<T, U>(opt: None, fn: (value: T) => Option<U>): None;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U>;\nexport function flatMap<T, U>(opt: Option<T>, fn: (value: T) => Option<U>): Option<U> {\n  return isNone(opt) ? NONE : fn(opt);\n}\n\n/**\n * Alias for flatMap. Chains Option-returning functions.\n * @param opt - The Option to chain\n * @param fn - Function returning an Option\n * @returns The result of fn(value) if Some, None otherwise\n */\nexport const andThen: typeof flatMap = flatMap;\n\n/**\n * Executes a side effect if Some, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tap(some(42), x => console.log(x)) // logs 42, returns Some(42)\n */\nexport function tap<T>(opt: None, fn: (value: T) => void): None;\nexport function tap<T>(opt: Some<T>, fn: (value: T) => void): Some<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T>;\nexport function tap<T>(opt: Option<T>, fn: (value: T) => void): Option<T> {\n  if (isSome(opt)) {\n    fn(opt);\n  }\n  return opt;\n}\n\n/**\n * Executes a side effect if None, then returns the original Option.\n * @param opt - The Option to tap\n * @param fn - Side effect function\n * @returns The original Option unchanged\n * @example\n * tapNone(none, () => console.log('missing')) // logs 'missing', returns None\n */\nexport function tapNone<T>(opt: Some<T>, fn: () => void): Some<T>;\nexport function tapNone(opt: None, fn: () => void): None;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T>;\nexport function tapNone<T>(opt: Option<T>, fn: () => void): Option<T> {\n  if (isNone(opt)) {\n    fn();\n  }\n  return opt;\n}\n\n/**\n * Returns true if None, or if Some and predicate returns true.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if None or predicate(value) is true\n * @example\n * isNoneOr(none, x => x > 2)    // true\n * isNoneOr(some(4), x => x > 2) // true\n * isNoneOr(some(1), x => x > 2) // false\n */\nexport function isNoneOr<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isNone(opt) || predicate(opt);\n}\n\n/**\n * Returns Some if the value passes the predicate, None otherwise.\n * @param opt - The Option to filter\n * @param predicate - Test function\n * @returns Some if predicate returns true, None otherwise\n * @example\n * filter(some(4), x => x > 2) // Some(4)\n * filter(some(1), x => x > 2) // None\n */\nexport function filter<T>(opt: None, predicate: (value: T) => boolean): None;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T>;\nexport function filter<T>(opt: Option<T>, predicate: (value: T) => boolean): Option<T> {\n  return isSome(opt) && predicate(opt) ? opt : NONE;\n}\n\n/**\n * Extracts the value from Some, throws if None.\n * @param opt - The Option to unwrap\n * @returns The contained value\n * @throws Error if opt is None\n * @example\n * unwrap(some(42)) // 42\n * unwrap(none)     // throws Error\n */\nexport function unwrap<T>(opt: Option<T>): T {\n  if (isNone(opt)) {\n    throw new Error('Called unwrap on None');\n  }\n  return opt;\n}\n\n/**\n * Extracts the value from Some, or returns a default value.\n * @param opt - The Option to unwrap\n * @param defaultValue - Value to return if None\n * @returns The contained value or defaultValue\n * @example\n * unwrapOr(some(42), 0) // 42\n * unwrapOr(none, 0)     // 0\n */\nexport function unwrapOr<T>(opt: Option<T>, defaultValue: T): T {\n  return isSome(opt) ? opt : defaultValue;\n}\n\n/**\n * Extracts the value from Some, or computes a default.\n * @param opt - The Option to unwrap\n * @param fn - Function to compute default value\n * @returns The contained value or fn()\n * @example\n * unwrapOrElse(some(42), () => 0) // 42\n * unwrapOrElse(none, () => 0)     // 0\n */\nexport function unwrapOrElse<T>(opt: Option<T>, fn: () => T): T {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Extracts the value from Some, throws with custom message if None.\n * @param opt - The Option to unwrap\n * @param message - Error message if None\n * @returns The contained value\n * @throws Error with message if opt is None\n * @example\n * expect(some(42), 'missing value') // 42\n * expect(none, 'missing value')     // throws Error('missing value')\n */\nexport function expect<T>(opt: Option<T>, message: string): T {\n  if (isNone(opt)) {\n    throw new Error(message);\n  }\n  return opt;\n}\n\n/**\n * Returns the first Some, or the second Option if the first is None.\n * @param opt - First Option\n * @param optb - Fallback Option\n * @returns opt if Some, optb otherwise\n * @example\n * or(some(1), some(2)) // Some(1)\n * or(none, some(2))    // Some(2)\n */\nexport function or<T>(opt: Some<T>, optb: Option<T>): Some<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T>;\nexport function or<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  return isSome(opt) ? opt : optb;\n}\n\n/**\n * Returns opt if Some, otherwise computes a fallback Option.\n * @param opt - First Option\n * @param fn - Function to compute fallback\n * @returns opt if Some, fn() otherwise\n * @example\n * orElse(some(1), () => some(2)) // Some(1)\n * orElse(none, () => some(2))    // Some(2)\n */\nexport function orElse<T>(opt: Some<T>, fn: () => Option<T>): Some<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T>;\nexport function orElse<T>(opt: Option<T>, fn: () => Option<T>): Option<T> {\n  return isSome(opt) ? opt : fn();\n}\n\n/**\n * Returns Some if exactly one of the Options is Some.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns Some if exactly one is Some, None otherwise\n * @example\n * xor(some(1), none)    // Some(1)\n * xor(none, some(2))    // Some(2)\n * xor(some(1), some(2)) // None\n * xor(none, none)       // None\n */\nexport function xor<T>(opt: Option<T>, optb: Option<T>): Option<T> {\n  const a = isSome(opt);\n  const b = isSome(optb);\n  if (a !== b) return a ? opt : optb;\n  return NONE;\n}\n\n/**\n * Returns optb if opt is Some, None otherwise.\n * @param opt - First Option\n * @param optb - Second Option\n * @returns optb if opt is Some, None otherwise\n * @example\n * and(some(1), some(2)) // Some(2)\n * and(none, some(2))    // None\n */\nexport function and<U>(opt: None, optb: Option<U>): None;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U>;\nexport function and<T, U>(opt: Option<T>, optb: Option<U>): Option<U> {\n  return isSome(opt) ? optb : NONE;\n}\n\n/**\n * Combines two Options into an Option of a tuple.\n * @param opt - First Option\n * @param other - Second Option\n * @returns Some([a, b]) if both are Some, None otherwise\n * @example\n * zip(some(1), some('a')) // Some([1, 'a'])\n * zip(some(1), none)      // None\n */\nexport function zip<T, U>(opt: Option<T>, other: Option<U>): Option<[T, U]> {\n  return isSome(opt) && isSome(other) ? ([opt, other] as Some<[T, U]>) : NONE;\n}\n\n/**\n * Splits an Option of a tuple into a tuple of Options.\n * @param opt - Option containing a tuple\n * @returns Tuple of Options\n * @example\n * unzip(some([1, 'a'])) // [Some(1), Some('a')]\n * unzip(none)           // [None, None]\n */\nexport function unzip<T, U>(opt: Option<[T, U]>): [Option<T>, Option<U>] {\n  if (isNone(opt)) return NONE_PAIR as [Option<T>, Option<U>];\n  const [a, b] = opt;\n  return [of(a), of(b)];\n}\n\n/**\n * Maps the value and returns it, or returns a default.\n * @param opt - The Option to map\n * @param defaultValue - Value if None\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultValue otherwise\n * @example\n * mapOr(some(2), 0, x => x * 2) // 4\n * mapOr(none, 0, x => x * 2)    // 0\n */\nexport function mapOr<T, U>(opt: Option<T>, defaultValue: U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultValue;\n}\n\n/**\n * Maps the value and returns it, or computes a default.\n * @param opt - The Option to map\n * @param defaultFn - Function to compute default\n * @param fn - Transform function\n * @returns fn(value) if Some, defaultFn() otherwise\n * @example\n * mapOrElse(some(2), () => 0, x => x * 2) // 4\n * mapOrElse(none, () => 0, x => x * 2)    // 0\n */\nexport function mapOrElse<T, U>(opt: Option<T>, defaultFn: () => U, fn: (value: T) => U): U {\n  return isSome(opt) ? fn(opt) : defaultFn();\n}\n\n/**\n * Flattens a nested Option.\n * @param opt - Option containing an Option\n * @returns The inner Option\n * @example\n * flatten(some(some(42))) // Some(42)\n * flatten(some(none))     // None\n * flatten(none)           // None\n */\nexport function flatten<T>(opt: Option<Option<T>>): Option<T> {\n  return isNone(opt) ? NONE : (opt as Option<T>);\n}\n\n/**\n * Checks if the Option contains a specific value (using ===).\n * @param opt - The Option to check\n * @param value - The value to compare\n * @returns true if Some and value matches\n * @example\n * contains(some(42), 42) // true\n * contains(some(42), 0)  // false\n * contains(none, 42)     // false\n */\nexport function contains<T>(opt: Option<T>, value: T): boolean {\n  return isSome(opt) && (opt === value || (opt !== opt && value !== value));\n}\n\n/**\n * Checks if Some and the value satisfies a predicate.\n * @param opt - The Option to check\n * @param predicate - Test function\n * @returns true if Some and predicate returns true\n * @example\n * isSomeAnd(some(4), x => x > 2) // true\n * isSomeAnd(some(1), x => x > 2) // false\n * isSomeAnd(none, x => x > 2)    // false\n */\nexport function isSomeAnd<T>(opt: Option<T>, predicate: (value: T) => boolean): boolean {\n  return isSome(opt) && predicate(opt);\n}\n\n/**\n * Converts an Option to an array.\n * @param opt - The Option to convert\n * @returns [value] if Some, [] if None\n * @example\n * toArray(some(42)) // [42]\n * toArray(none)     // []\n */\nexport function toArray<T>(opt: Option<T>): readonly T[] {\n  return isSome(opt) ? [opt] : (EMPTY as readonly T[]);\n}\n\n/**\n * Converts an Option to a nullable value.\n * @param opt - The Option to convert\n * @returns The value if Some, null if None\n * @example\n * toNullable(some(42)) // 42\n * toNullable(none)     // null\n */\nexport function toNullable<T>(opt: Option<T>): T | null {\n  return isSome(opt) ? opt : null;\n}\n\n/**\n * Converts an Option to an undefined-able value.\n * @param opt - The Option to convert\n * @returns The value if Some, undefined if None\n * @example\n * toUndefined(some(42)) // 42\n * toUndefined(none)     // undefined\n */\nexport function toUndefined<T>(opt: Option<T>): T | undefined {\n  return isSome(opt) ? opt : undefined;\n}\n\n/**\n * Pattern matches on an Option, handling both Some and None cases.\n * @param opt - The Option to match\n * @param onSome - Handler for Some case\n * @param onNone - Handler for None case\n * @returns Result of the matching handler\n * @example\n * match(some(42), x => x * 2, () => 0) // 84\n * match(none, x => x * 2, () => 0)     // 0\n */\nexport function match<T, U>(opt: Option<T>, onSome: (value: T) => U, onNone: () => U): U {\n  return isSome(opt) ? onSome(opt) : onNone();\n}\n\n/**\n * Converts an Option to a Result, using a provided error if None.\n * @param opt - The Option to convert\n * @param error - Error value if None\n * @returns Ok(value) if Some, Err(error) if None\n * @example\n * okOr(some(42), 'missing') // Ok(42)\n * okOr(none, 'missing')     // Err('missing')\n */\nexport function okOr<T, E>(opt: Option<T>, error: E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(error);\n}\n\n/**\n * Converts an Option to a Result, computing the error if None.\n * @param opt - The Option to convert\n * @param fn - Function to compute error\n * @returns Ok(value) if Some, Err(fn()) if None\n * @example\n * okOrElse(some(42), () => 'missing') // Ok(42)\n * okOrElse(none, () => 'missing')     // Err('missing')\n */\nexport function okOrElse<T, E>(opt: Option<T>, fn: () => E): Result<T, E> {\n  return isSome(opt) ? (opt as unknown as Ok<T>) : err(fn());\n}\n\n/**\n * Extracts the Ok value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(value) if Ok, None if Err\n * @example\n * ofOk(ok(42))        // Some(42)\n * ofOk(err('failed')) // None\n */\nexport function ofOk<T, E>(result: Result<T, E>): Option<T> {\n  if (!isOk(result) || !isSome(result)) {\n    return NONE;\n  }\n  return result as Some<T>;\n}\n\n/**\n * Extracts the Err value from a Result as an Option.\n * @param result - The Result to convert\n * @returns Some(error) if Err, None if Ok\n * @example\n * ofErr(err('failed')) // Some('failed')\n * ofErr(ok(42))        // None\n */\nexport function ofErr<T, E>(result: Result<T, E>): Option<E> {\n  if (!isErr(result)) {\n    return NONE;\n  }\n  const error = (result as { error: E }).error;\n  if (!isSome(error)) {\n    return NONE;\n  }\n  return error as Some<E>;\n}\n"],"names":["NONE","EMPTY","isSome","isNone","optionOf","of","err","isOk","isErr","NONE_PAIR","Object","freeze","fromNullable","value","fromPromise","promise","onRejected","error","unwrapOrReturn","opt","onNone","assertSome","message","Error","satisfiesOption","_","filterMap","values","fn","collected","mapped","push","findMap","map","result","undefined","flatMap","andThen","tap","tapNone","isNoneOr","predicate","filter","unwrap","unwrapOr","defaultValue","unwrapOrElse","expect","or","optb","orElse","xor","a","b","and","zip","other","unzip","mapOr","mapOrElse","defaultFn","flatten","contains","isSomeAnd","toArray","toNullable","toUndefined","match","onSome","okOr","okOrElse","ofOk","ofErr"],"mappings":"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"}