nalloc 0.1.0 → 0.2.1

package/README.md

@@ -44,7 +44,7 @@ npm install nalloc
 ## Quick start
 
 ```ts
-import { Option, Result, ok, err, none, safeTry, unwrap } from 'nalloc';
+import { Option, Result, ok, err, none, pipe, gen } from 'nalloc';
 
 // Option: the value IS the Option
 const port = Option.fromNullable(process.env.PORT);
@@ -58,12 +58,19 @@ const data = Result.match(
   error => ({ fallback: true })
 );
 
-// safeTry: Rust-like ? operator
-const result = safeTry(() => {
-  const a = unwrap(parseNumber('10'));
-  const b = unwrap(parseNumber('5'));
+// gen: Rust-like ? operator with type-safe errors
+const result = gen(function*($) {
+  const a = yield* $(parseNumber('10'));
+  const b = yield* $(parseNumber('5'));
   return a + b;
-}); // Ok(15) or Err(...)
+}); // Result<number, ParseError>
+
+// pipe: left-to-right composition
+const userId = pipe(
+  Result.tryCatch(() => JSON.parse(raw)),
+  r => Result.map(r, data => data.userId),
+  r => Result.unwrapOr(r, 0),
+);
 ```
 
 ## How it works
@@ -103,8 +110,8 @@ import * as O from 'fp-ts/Option';
 pipe(O.some(42), O.map(x => x * 2));
 
 // nalloc - simpler, faster
-import { Option } from 'nalloc';
-Option.map(42, x => x * 2);               // value IS the Option
+import { Option, pipe } from 'nalloc';
+pipe(42, v => Option.map(v, x => x * 2)); // built-in pipe, value IS the Option
 ```
 
 ### From oxide.ts
@@ -146,7 +153,7 @@ Option.unwrapOr(42, 0);                  // value IS the Option
 The API mirrors Rust's `Option` and `Result`:
 
 ```ts
-import { Option, Result, ok, err, none, safeTry, unwrap } from 'nalloc';
+import { Option, Result, ok, err, none, gen } from 'nalloc';
 
 // Rust: Some(42).map(|x| x * 2)
 Option.map(42, x => x * 2);
@@ -157,9 +164,9 @@ Result.andThen(ok(42), x => x > 0 ? ok(x) : err('negative'));
 // Rust: result.unwrap_or(0)
 Result.unwrapOr(result, 0);
 
-// Rust: let value = try!(get_value())  /  let value = get_value()?
-const value = safeTry(() => {
-  const a = unwrap(getValue());
+// Rust: let value = get_value()?
+const value = gen(function*($) {
+  const a = yield* $(getValue());
   return a + 1;
 });
 ```
@@ -205,7 +212,7 @@ const maybeUser = await Option.fromPromise(fetchUserById(id));
 A `Result<T, E>` is either `Ok<T>` (the value itself) or `Err<E>` (a wrapper).
 
 ```ts
-import { Result, ok, err, safeTry, safeTryAsync, unwrap } from 'nalloc';
+import { Result, ok, err, gen, genAsync, pipe } from 'nalloc';
 
 // Wrap throwing functions
 const parsed = Result.tryCatch(
@@ -213,24 +220,35 @@ const parsed = Result.tryCatch(
   e => 'invalid json'
 );
 
-// safeTry: Rust-like ? operator for imperative error handling
-const result = safeTry(() => {
-  const config = unwrap(parseConfig(raw));
-  const db = unwrap(connectDb(config.url));
+// gen: Rust-like ? operator with preserved error types
+const result = gen(function*($) {
+  const config = yield* $(parseConfig(raw));
+  const db = yield* $(connectDb(config.url));
   return db.query('SELECT 1');
-});
+}); // Result<QueryResult, ConfigError | DbError>
 
-// Async safeTry
-const data = await safeTryAsync(async () => {
-  const res = unwrap(await fetchUser(id));
-  const posts = unwrap(await fetchPosts(res.id));
+// Async gen
+const data = await genAsync(async function*($) {
+  const res = yield* $(await Result.fromPromise(fetchUser(id)));
+  const posts = yield* $(await Result.fromPromise(fetchPosts(res.id)));
   return { user: res, posts };
-});
+}); // Promise<Result<{user, posts}, unknown>>
 
-// Transform
-const userId = Result.map(parsed, data => data.userId);
-const validated = Result.flatMap(userId, id =>
-  id > 0 ? ok(id) : err('invalid id')
+// wrap / toThrowable: ecosystem boundaries
+const safeParse = Result.wrap(JSON.parse);            // throwing -> Result
+safeParse('{"a":1}');                                 // Ok({a: 1})
+const throwingFind = Result.toThrowable(findUser);    // Result -> throwing
+throwingFind('123');                                  // returns User or throws
+
+// Standard Schema validation (Zod, Valibot, ArkType, etc.)
+const validated = Result.fromSchema(userSchema, input);
+// Result<User, readonly SchemaIssue[]>
+
+// Transform with pipe
+const userId = pipe(
+  parsed,
+  r => Result.map(r, data => data.userId),
+  r => Result.flatMap(r, id => id > 0 ? ok(id) : err('invalid id')),
 );
 
 // Pattern match
@@ -289,6 +307,7 @@ Iter.tryForEach(items, item => processItem(item));
 | `flatMap(opt, fn)` | Chain Option-returning functions |
 | `andThen(opt, fn)` | Alias for flatMap |
 | `tap(opt, fn)` | Side effect on Some, return original |
+| `tapNone(opt, fn)` | Side effect on None, return original |
 | `filter(opt, predicate)` | Keep Some if predicate passes |
 | `match(opt, onSome, onNone)` | Pattern match |
 | `unwrap(opt)` | Extract or throw |
@@ -327,6 +346,11 @@ Iter.tryForEach(items, item => processItem(item));
 | `tryCatch(fn, onError?)` | Wrap throwing function |
 | `tryCatchMaybePromise(fn, onError?)` | Wrap sync-or-async, preserving sync |
 | `of(fn)` | Alias for tryCatch (no error mapper) |
+| `wrap(fn, onError?)` | Wrap throwing function once, reuse |
+| `toThrowable(fn)` | Inverse of wrap: Result-returning to throwing |
+| `fromSchema(schema, value)` | Validate via Standard Schema v1 |
+| `gen(fn)` | Generator do-notation with typed errors |
+| `genAsync(fn)` | Async generator do-notation |
 | `safeTry(fn)` | Imperative error handling with unwrap |
 | `safeTryAsync(fn)` | Async version of safeTry |
 | `unwrap(result)` | Extract Ok or throw error value |
@@ -382,6 +406,12 @@ Iter.tryForEach(items, item => processItem(item));
 | `tryFold(source, init, fn)` | Fold with early exit on Err |
 | `tryForEach(source, fn)` | Iterate with early exit on Err |
 
+### Utilities
+
+| Function | Description |
+|----------|-------------|
+| `pipe(value, ...fns)` | Thread value through functions left-to-right |
+
 ## Comparison
 
 | Feature | nalloc | neverthrow | fp-ts | oxide.ts | ts-results |
@@ -393,7 +423,10 @@ Iter.tryForEach(items, item => processItem(item));
 | 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 |
+| gen (? operator) | Yes | Yes | No | No | No |
+| pipe | Yes | No | Yes | No | No |
+| Schema validation | Yes | No | No | No | No |
+| Ecosystem interop | Yes | No | No | No | No |
 
 ## Alternatives
 

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);
 }
@@ -181,6 +188,12 @@ function tap(opt, fn) {
     }
     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);
 }
@@ -227,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),

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 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 * 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 || (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","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

@@ -117,6 +117,17 @@ export declare const andThen: typeof flatMap;
 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);
 }
@@ -53,6 +57,12 @@ export function tap(opt, fn) {
     }
     return opt;
 }
+export function tapNone(opt, fn) {
+    if (isNone(opt)) {
+        fn();
+    }
+    return opt;
+}
 export function isNoneOr(opt, predicate) {
     return isNone(opt) || predicate(opt);
 }
@@ -99,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),