npm - @onrails/maybe - Versions diffs - 0.1.2 → 0.1.4 - Mend

@onrails/maybe 0.1.2 → 0.1.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (13) hide show

package/dist/fluent.cjs CHANGED Viewed

@@ -24,8 +24,7 @@ function match(...args) {
   const [onSome, onNone] = args;
   return (maybe) => matchImpl(maybe, onSome, onNone);
 }
-var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
-var unwrapOr = getOrElse;
+var unwrapOr = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
 var tapImpl = (maybe, fn) => {
   if (isSome(maybe)) fn(maybe.value);
   return maybe;
@@ -66,7 +65,7 @@ var fluent = (maybe) => Object.assign(maybe, {
     return match(maybe, onSome, onNone);
   },
   getOrElse(defaultValue) {
-    return getOrElse(maybe, defaultValue);
+    return unwrapOr(maybe, defaultValue);
   },
   unwrapOr(defaultValue) {
     return unwrapOr(maybe, defaultValue);

package/dist/fluent.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/maybe.ts","../src/fluent.ts"],"names":[],"mappings":"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","file":"fluent.cjs","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/* Fantasy Land `of` — alias of {@link some}. /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/* Collision-free alias — mirrors `matchResult` on `@onrails/result`. /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * getOrElse(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const getOrElse = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/* Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. /\nexport const unwrapOr = getOrElse;\n\n/\n Unwraps the `Some` value or throws if the value is `None`. Use in tests\n * or at the boundary of an assertion; prefer `match` / `getOrElse` in\n * production code paths.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import {\n andThen,\n flatMap,\n getOrElse,\n type Maybe,\n map,\n match,\n tap,\n tapNone,\n unwrapOr,\n} from \"./maybe.js\";\n\nexport type FluentMaybe<T> = Maybe<T> & {\n map<U>(fn: (value: T) => U): FluentMaybe<U>;\n flatMap<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n andThen<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n tap(fn: (value: T) => void): FluentMaybe<T>;\n tapNone(fn: () => void): FluentMaybe<T>;\n match<U>(onSome: (value: T) => U, onNone: () => U): U;\n getOrElse(defaultValue: T): T;\n unwrapOr(defaultValue: T): T;\n};\n\nexport const fluent = <T>(maybe: Maybe<T>): FluentMaybe<T> =>\n Object.assign(maybe, {\n map<U>(fn: (value: T) => U) {\n return fluent(map(maybe, fn));\n },\n flatMap<U>(fn: (value: T) => Maybe<U>) {\n return fluent(flatMap(maybe, fn));\n },\n tap(fn: (value: T) => void) {\n return fluent(tap(maybe, fn));\n },\n tapNone(fn: () => void) {\n return fluent(tapNone(maybe, fn));\n },\n andThen<U>(fn: (value: T) => Maybe<U>) {\n return fluent(andThen(maybe, fn));\n },\n match<U>(onSome: (value: T) => U, onNone: () => U) {\n return match(maybe, onSome, onNone);\n },\n getOrElse(defaultValue: T) {\n return getOrElse(maybe, defaultValue);\n },\n unwrapOr(defaultValue: T) {\n return unwrapOr(maybe, defaultValue);\n },\n });\n"]}
1	+ {"version":3,"sources":["../src/maybe.ts","../src/fluent.ts"],"names":[],"mappings":"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","file":"fluent.cjs","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/\n Fantasy Land `of` — alias of {@link some}.\n * @deprecated Use {@link some} instead.\n /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/\n Collision-free alias — mirrors `matchResult` on `@onrails/result`.\n * @deprecated Namespace import carriers (e.g., `import * as Maybe from \"@onrails/maybe\"`) and use canonical {@link match} instead.\n /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * unwrapOr(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const unwrapOr = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @deprecated Use canonical {@link unwrapOr} instead.\n /\nexport const getOrElse = unwrapOr;\n\n/\n Unwraps the `Some` value or throws if the value is `None`.\n \n @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.\n * Allowed in `.spec.ts` / `.test.ts`; flagged elsewhere by the plugins.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import { andThen, flatMap, type Maybe, map, match, tap, tapNone, unwrapOr } from \"./maybe.js\";\n\nexport type FluentMaybe<T> = Maybe<T> & {\n map<U>(fn: (value: T) => U): FluentMaybe<U>;\n flatMap<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n andThen<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n tap(fn: (value: T) => void): FluentMaybe<T>;\n tapNone(fn: () => void): FluentMaybe<T>;\n match<U>(onSome: (value: T) => U, onNone: () => U): U;\n getOrElse(defaultValue: T): T;\n unwrapOr(defaultValue: T): T;\n};\n\nexport const fluent = <T>(maybe: Maybe<T>): FluentMaybe<T> =>\n Object.assign(maybe, {\n map<U>(fn: (value: T) => U) {\n return fluent(map(maybe, fn));\n },\n flatMap<U>(fn: (value: T) => Maybe<U>) {\n return fluent(flatMap(maybe, fn));\n },\n tap(fn: (value: T) => void) {\n return fluent(tap(maybe, fn));\n },\n tapNone(fn: () => void) {\n return fluent(tapNone(maybe, fn));\n },\n andThen<U>(fn: (value: T) => Maybe<U>) {\n return fluent(andThen(maybe, fn));\n },\n match<U>(onSome: (value: T) => U, onNone: () => U) {\n return match(maybe, onSome, onNone);\n },\n getOrElse(defaultValue: T) {\n return unwrapOr(maybe, defaultValue);\n },\n unwrapOr(defaultValue: T) {\n return unwrapOr(maybe, defaultValue);\n },\n });\n"]}

package/dist/fluent.js CHANGED Viewed

@@ -22,8 +22,7 @@ function match(...args) {
   const [onSome, onNone] = args;
   return (maybe) => matchImpl(maybe, onSome, onNone);
 }
-var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
-var unwrapOr = getOrElse;
+var unwrapOr = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
 var tapImpl = (maybe, fn) => {
   if (isSome(maybe)) fn(maybe.value);
   return maybe;
@@ -64,7 +63,7 @@ var fluent = (maybe) => Object.assign(maybe, {
     return match(maybe, onSome, onNone);
   },
   getOrElse(defaultValue) {
-    return getOrElse(maybe, defaultValue);
+    return unwrapOr(maybe, defaultValue);
   },
   unwrapOr(defaultValue) {
     return unwrapOr(maybe, defaultValue);

package/dist/fluent.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/maybe.ts","../src/fluent.ts"],"names":[],"mappings":"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","file":"fluent.js","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/* Fantasy Land `of` — alias of {@link some}. /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/* Collision-free alias — mirrors `matchResult` on `@onrails/result`. /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * getOrElse(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const getOrElse = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/* Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. /\nexport const unwrapOr = getOrElse;\n\n/\n Unwraps the `Some` value or throws if the value is `None`. Use in tests\n * or at the boundary of an assertion; prefer `match` / `getOrElse` in\n * production code paths.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import {\n andThen,\n flatMap,\n getOrElse,\n type Maybe,\n map,\n match,\n tap,\n tapNone,\n unwrapOr,\n} from \"./maybe.js\";\n\nexport type FluentMaybe<T> = Maybe<T> & {\n map<U>(fn: (value: T) => U): FluentMaybe<U>;\n flatMap<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n andThen<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n tap(fn: (value: T) => void): FluentMaybe<T>;\n tapNone(fn: () => void): FluentMaybe<T>;\n match<U>(onSome: (value: T) => U, onNone: () => U): U;\n getOrElse(defaultValue: T): T;\n unwrapOr(defaultValue: T): T;\n};\n\nexport const fluent = <T>(maybe: Maybe<T>): FluentMaybe<T> =>\n Object.assign(maybe, {\n map<U>(fn: (value: T) => U) {\n return fluent(map(maybe, fn));\n },\n flatMap<U>(fn: (value: T) => Maybe<U>) {\n return fluent(flatMap(maybe, fn));\n },\n tap(fn: (value: T) => void) {\n return fluent(tap(maybe, fn));\n },\n tapNone(fn: () => void) {\n return fluent(tapNone(maybe, fn));\n },\n andThen<U>(fn: (value: T) => Maybe<U>) {\n return fluent(andThen(maybe, fn));\n },\n match<U>(onSome: (value: T) => U, onNone: () => U) {\n return match(maybe, onSome, onNone);\n },\n getOrElse(defaultValue: T) {\n return getOrElse(maybe, defaultValue);\n },\n unwrapOr(defaultValue: T) {\n return unwrapOr(maybe, defaultValue);\n },\n });\n"]}
1	+ {"version":3,"sources":["../src/maybe.ts","../src/fluent.ts"],"names":[],"mappings":";AAYO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAgB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAKxE,IAAM,MAAA,GAAS,CAAI,KAAA,KAAmC,KAAA,CAAM,IAAA,KAAS,MAAA;AAqB5E,IAAM,OAAA,GAAU,CAAO,KAAA,EAAiB,EAAA,KACtC,MAAA,CAAO,KAAK,CAAA,GAAI,IAAA,CAAK,EAAA,CAAG,KAAA,CAAM,KAAK,CAAC,IAAI,IAAA,EAAQ;AAa3C,SAAS,OACX,IAAA,EACM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,OAAA,CAAQ,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACtD,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAA;AACrD;AAEA,IAAM,WAAA,GAAc,CAAO,KAAA,EAAiB,EAAA,KAC1C,MAAA,CAAO,KAAK,CAAA,GAAI,EAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAI,IAAA,EAAQ;AAerC,SAAS,WACX,IAAA,EAGM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,WAAA,CAAY,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAC1D,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,WAAA,CAAY,KAAA,EAAO,EAAE,CAAA;AACzD;AAGO,IAAM,OAAA,GAAU,OAAA;AAEvB,IAAM,SAAA,GAAY,CAAO,KAAA,EAAiB,MAAA,EAAyB,MAAA,KACjE,MAAA,CAAO,KAAK,CAAA,GAAI,MAAA,CAAO,KAAA,CAAM,KAAK,CAAA,GAAI,MAAA,EAAO;AAoBxC,SAAS,SACX,IAAA,EAGM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,SAAA,CAAU,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACjE,EAAA,MAAM,CAAC,MAAA,EAAQ,MAAM,CAAA,GAAI,IAAA;AACzB,EAAA,OAAO,CAAC,KAAA,KAA0B,SAAA,CAAU,KAAA,EAAO,QAAQ,MAAM,CAAA;AACnE;AAgBO,IAAM,QAAA,GAAW,CAAI,KAAA,EAAiB,YAAA,KAC3C,OAAO,KAAK,CAAA,GAAI,MAAM,KAAA,GAAQ,YAAA;AAwEhC,IAAM,OAAA,GAAU,CAAI,KAAA,EAAiB,EAAA,KAAqC;AACxE,EAAA,IAAI,MAAA,CAAO,KAAK,CAAA,EAAG,EAAA,CAAG,MAAM,KAAK,CAAA;AACjC,EAAA,OAAO,KAAA;AACT,CAAA;AAcO,SAAS,OACX,IAAA,EACM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,OAAA,CAAQ,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACtD,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAA;AACrD;AAEA,IAAM,WAAA,GAAc,CAAI,KAAA,EAAiB,EAAA,KAA6B;AACpE,EAAA,IAAI,MAAA,CAAO,KAAK,CAAA,EAAG,EAAA,EAAG;AACtB,EAAA,OAAO,KAAA;AACT,CAAA;AAcO,SAAS,WAAW,IAAA,EAA4D;AACrF,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,WAAA,CAAY,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAC1D,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,WAAA,CAAY,KAAA,EAAO,EAAE,CAAA;AACzD;;;AC5QO,IAAM,MAAA,GAAS,CAAI,KAAA,KACxB,MAAA,CAAO,OAAO,KAAA,EAAO;AAAA,EACnB,IAAO,EAAA,EAAqB;AAC1B,IAAA,OAAO,MAAA,CAAO,GAAA,CAAI,KAAA,EAAO,EAAE,CAAC,CAAA;AAAA,EAC9B,CAAA;AAAA,EACA,QAAW,EAAA,EAA4B;AACrC,IAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAC,CAAA;AAAA,EAClC,CAAA;AAAA,EACA,IAAI,EAAA,EAAwB;AAC1B,IAAA,OAAO,MAAA,CAAO,GAAA,CAAI,KAAA,EAAO,EAAE,CAAC,CAAA;AAAA,EAC9B,CAAA;AAAA,EACA,QAAQ,EAAA,EAAgB;AACtB,IAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAC,CAAA;AAAA,EAClC,CAAA;AAAA,EACA,QAAW,EAAA,EAA4B;AACrC,IAAA,OAAO,MAAA,CAAO,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAC,CAAA;AAAA,EAClC,CAAA;AAAA,EACA,KAAA,CAAS,QAAyB,MAAA,EAAiB;AACjD,IAAA,OAAO,KAAA,CAAM,KAAA,EAAO,MAAA,EAAQ,MAAM,CAAA;AAAA,EACpC,CAAA;AAAA,EACA,UAAU,YAAA,EAAiB;AACzB,IAAA,OAAO,QAAA,CAAS,OAAO,YAAY,CAAA;AAAA,EACrC,CAAA;AAAA,EACA,SAAS,YAAA,EAAiB;AACxB,IAAA,OAAO,QAAA,CAAS,OAAO,YAAY,CAAA;AAAA,EACrC;AACF,CAAC","file":"fluent.js","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/\n Fantasy Land `of` — alias of {@link some}.\n * @deprecated Use {@link some} instead.\n /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/\n Collision-free alias — mirrors `matchResult` on `@onrails/result`.\n * @deprecated Namespace import carriers (e.g., `import * as Maybe from \"@onrails/maybe\"`) and use canonical {@link match} instead.\n /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * unwrapOr(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const unwrapOr = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @deprecated Use canonical {@link unwrapOr} instead.\n /\nexport const getOrElse = unwrapOr;\n\n/\n Unwraps the `Some` value or throws if the value is `None`.\n \n @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.\n * Allowed in `.spec.ts` / `.test.ts`; flagged elsewhere by the plugins.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import { andThen, flatMap, type Maybe, map, match, tap, tapNone, unwrapOr } from \"./maybe.js\";\n\nexport type FluentMaybe<T> = Maybe<T> & {\n map<U>(fn: (value: T) => U): FluentMaybe<U>;\n flatMap<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n andThen<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;\n tap(fn: (value: T) => void): FluentMaybe<T>;\n tapNone(fn: () => void): FluentMaybe<T>;\n match<U>(onSome: (value: T) => U, onNone: () => U): U;\n getOrElse(defaultValue: T): T;\n unwrapOr(defaultValue: T): T;\n};\n\nexport const fluent = <T>(maybe: Maybe<T>): FluentMaybe<T> =>\n Object.assign(maybe, {\n map<U>(fn: (value: T) => U) {\n return fluent(map(maybe, fn));\n },\n flatMap<U>(fn: (value: T) => Maybe<U>) {\n return fluent(flatMap(maybe, fn));\n },\n tap(fn: (value: T) => void) {\n return fluent(tap(maybe, fn));\n },\n tapNone(fn: () => void) {\n return fluent(tapNone(maybe, fn));\n },\n andThen<U>(fn: (value: T) => Maybe<U>) {\n return fluent(andThen(maybe, fn));\n },\n match<U>(onSome: (value: T) => U, onNone: () => U) {\n return match(maybe, onSome, onNone);\n },\n getOrElse(defaultValue: T) {\n return unwrapOr(maybe, defaultValue);\n },\n unwrapOr(defaultValue: T) {\n return unwrapOr(maybe, defaultValue);\n },\n });\n"]}

package/dist/index.cjs CHANGED Viewed

@@ -27,8 +27,8 @@ function match(...args) {
   return (maybe) => matchImpl(maybe, onSome, onNone);
 }
 var matchMaybe = match;
-var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
-var unwrapOr = getOrElse;
+var unwrapOr = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
+var getOrElse = unwrapOr;
 var unwrap = (maybe) => {
   if (isNone(maybe)) {
     throw new Error("Called unwrap on None");

package/dist/index.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/maybe.ts"],"names":[],"mappings":";;;AAYO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM;AAG/D,IAAM,EAAA,GAAK;AAUX,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS;AAKxE,IAAM,MAAA,GAAS,CAAI,KAAA,KAAmC,KAAA,CAAM,IAAA,KAAS;AAYrE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK;AAQxC,IAAM,OAAA,GAAU,CAAO,KAAA,EAAiB,EAAA,KACtC,MAAA,CAAO,KAAK,CAAA,GAAI,IAAA,CAAK,EAAA,CAAG,KAAA,CAAM,KAAK,CAAC,IAAI,IAAA,EAAQ;AAa3C,SAAS,OACX,IAAA,EACM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,OAAA,CAAQ,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACtD,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAA;AACrD;AAEA,IAAM,WAAA,GAAc,CAAO,KAAA,EAAiB,EAAA,KAC1C,MAAA,CAAO,KAAK,CAAA,GAAI,EAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAI,IAAA,EAAQ;AAerC,SAAS,WACX,IAAA,EAGM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,WAAA,CAAY,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAC1D,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,WAAA,CAAY,KAAA,EAAO,EAAE,CAAA;AACzD;AAGO,IAAM,OAAA,GAAU;AAEvB,IAAM,SAAA,GAAY,CAAO,KAAA,EAAiB,MAAA,EAAyB,MAAA,KACjE,MAAA,CAAO,KAAK,CAAA,GAAI,MAAA,CAAO,KAAA,CAAM,KAAK,CAAA,GAAI,MAAA,EAAO;AAoBxC,SAAS,SACX,IAAA,EAGM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,SAAA,CAAU,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACjE,EAAA,MAAM,CAAC,MAAA,EAAQ,MAAM,CAAA,GAAI,IAAA;AACzB,EAAA,OAAO,CAAC,KAAA,KAA0B,SAAA,CAAU,KAAA,EAAO,QAAQ,MAAM,CAAA;AACnE;AAGO,IAAM,UAAA,GAAa;AAUnB,IAAM,SAAA,GAAY,CAAI,KAAA,EAAiB,YAAA,KAC5C,OAAO,KAAK,CAAA,GAAI,MAAM,KAAA,GAAQ;AAGzB,IAAM,QAAA,GAAW;AAYjB,IAAM,MAAA,GAAS,CAAI,KAAA,KAAuB;AAC/C,EAAA,IAAI,MAAA,CAAO,KAAK,CAAA,EAAG;AACjB,IAAA,MAAM,IAAI,MAAM,uBAAuB,CAAA;AAAA,EACzC;AACA,EAAA,OAAO,KAAA,CAAM,KAAA;AACf;AAUO,IAAM,OAAA,GAAU,CAAI,MAAA,KAAqC;AAC9D,EAAA,MAAM,MAAW,EAAC;AAClB,EAAA,KAAA,MAAW,KAAK,MAAA,EAAQ;AACtB,IAAA,IAAI,MAAA,CAAO,CAAC,CAAA,EAAG;AACb,MAAA,GAAA,CAAI,IAAA,CAAK,EAAE,KAAK,CAAA;AAAA,IAClB;AAAA,EACF;AACA,EAAA,OAAO,GAAA;AACT;AAcO,IAAM,UAAA,GAAa,CAAO,KAAA,EAAqB,EAAA,KACpD,QAAQ,KAAA,CAAM,GAAA,CAAI,EAAE,CAAC;AAWhB,IAAM,QAAA,GAAW,CAAO,KAAA,EAA6B,EAAA,KAC1D,YAAY,YAAA,CAAa,KAAK,GAAG,EAAE;AAErC,IAAM,OAAA,GAAU,CAAI,KAAA,EAAiB,EAAA,KAAqC;AACxE,EAAA,IAAI,MAAA,CAAO,KAAK,CAAA,EAAG,EAAA,CAAG,MAAM,KAAK,CAAA;AACjC,EAAA,OAAO,KAAA;AACT,CAAA;AAcO,SAAS,OACX,IAAA,EACM;AACT,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,OAAA,CAAQ,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AACtD,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,OAAA,CAAQ,KAAA,EAAO,EAAE,CAAA;AACrD;AAEA,IAAM,WAAA,GAAc,CAAI,KAAA,EAAiB,EAAA,KAA6B;AACpE,EAAA,IAAI,MAAA,CAAO,KAAK,CAAA,EAAG,EAAA,EAAG;AACtB,EAAA,OAAO,KAAA;AACT,CAAA;AAcO,SAAS,WAAW,IAAA,EAA4D;AACrF,EAAA,IAAI,IAAA,CAAK,MAAA,KAAW,CAAA,EAAG,OAAO,WAAA,CAAY,KAAK,CAAC,CAAA,EAAG,IAAA,CAAK,CAAC,CAAC,CAAA;AAC1D,EAAA,MAAM,EAAA,GAAK,KAAK,CAAC,CAAA;AACjB,EAAA,OAAO,CAAC,KAAA,KAA0B,WAAA,CAAY,KAAA,EAAO,EAAE,CAAA;AACzD","file":"index.cjs","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/* Fantasy Land `of` — alias of {@link some}. /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/* Collision-free alias — mirrors `matchResult` on `@onrails/result`. /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * getOrElse(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const getOrElse = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/* Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. /\nexport const unwrapOr = getOrElse;\n\n/\n Unwraps the `Some` value or throws if the value is `None`. Use in tests\n * or at the boundary of an assertion; prefer `match` / `getOrElse` in\n * production code paths.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n"]}
1	+ {"version":3,"sources":["../src/maybe.ts"],"names":[],"mappings":"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","file":"index.cjs","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/\n Fantasy Land `of` — alias of {@link some}.\n * @deprecated Use {@link some} instead.\n /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/\n Collision-free alias — mirrors `matchResult` on `@onrails/result`.\n * @deprecated Namespace import carriers (e.g., `import * as Maybe from \"@onrails/maybe\"`) and use canonical {@link match} instead.\n /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * unwrapOr(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const unwrapOr = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @deprecated Use canonical {@link unwrapOr} instead.\n /\nexport const getOrElse = unwrapOr;\n\n/\n Unwraps the `Some` value or throws if the value is `None`.\n \n @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.\n * Allowed in `.spec.ts` / `.test.ts`; flagged elsewhere by the plugins.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n"]}

package/dist/index.d.cts CHANGED Viewed

@@ -9,7 +9,10 @@ import { M as Maybe, N as None, S as Some } from './types-vkiMAo4w.cjs';
  * ```
  */
 declare const some: <T>(value: T) => Maybe<T>;
-/** Fantasy Land `of` — alias of {@link some}. */
+/**
+ * Fantasy Land `of` — alias of {@link some}.
+ * @deprecated Use {@link some} instead.
+ */
 declare const of: <T>(value: T) => Maybe<T>;
 /**
  * The `None` value — represents expected absence. Not a failure.
@@ -90,23 +93,31 @@ declare const andThen: typeof flatMap;
  */
 declare function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;
 declare function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;
-/** Collision-free alias — mirrors `matchResult` on `@onrails/result`. */
+/**
+ * Collision-free alias — mirrors `matchResult` on `@onrails/result`.
+ * @deprecated Namespace import carriers (e.g., `import * as Maybe from "@onrails/maybe"`) and use canonical {@link match} instead.
+ */
 declare const matchMaybe: typeof match;
 /**
  * Returns the `Some` value, or `defaultValue` when the value is `None`.
  *
  * @example
  * ```ts
- * getOrElse(fromNullable(user), { name: "guest" });
+ * unwrapOr(fromNullable(user), { name: "guest" });
  * ```
  */
-declare const getOrElse: <T>(maybe: Maybe<T>, defaultValue: T) => T;
-/** Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. */
 declare const unwrapOr: <T>(maybe: Maybe<T>, defaultValue: T) => T;
 /**
- * Unwraps the `Some` value or throws if the value is `None`. Use in tests
- * or at the boundary of an assertion; prefer `match` / `getOrElse` in
- * production code paths.
+ * Returns the `Some` value, or `defaultValue` when the value is `None`.
+ *
+ * @deprecated Use canonical {@link unwrapOr} instead.
+ */
+declare const getOrElse: <T>(maybe: Maybe<T>, defaultValue: T) => T;
+/**
+ * Unwraps the `Some` value or throws if the value is `None`.
+ *
+ * @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.
+ * Allowed in `*.spec.ts` / `*.test.ts`; flagged elsewhere by the plugins.
  *
  * @example
  * ```ts

package/dist/index.d.ts CHANGED Viewed

@@ -9,7 +9,10 @@ import { M as Maybe, N as None, S as Some } from './types-vkiMAo4w.js';
  * ```
  */
 declare const some: <T>(value: T) => Maybe<T>;
-/** Fantasy Land `of` — alias of {@link some}. */
+/**
+ * Fantasy Land `of` — alias of {@link some}.
+ * @deprecated Use {@link some} instead.
+ */
 declare const of: <T>(value: T) => Maybe<T>;
 /**
  * The `None` value — represents expected absence. Not a failure.
@@ -90,23 +93,31 @@ declare const andThen: typeof flatMap;
  */
 declare function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;
 declare function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;
-/** Collision-free alias — mirrors `matchResult` on `@onrails/result`. */
+/**
+ * Collision-free alias — mirrors `matchResult` on `@onrails/result`.
+ * @deprecated Namespace import carriers (e.g., `import * as Maybe from "@onrails/maybe"`) and use canonical {@link match} instead.
+ */
 declare const matchMaybe: typeof match;
 /**
  * Returns the `Some` value, or `defaultValue` when the value is `None`.
  *
  * @example
  * ```ts
- * getOrElse(fromNullable(user), { name: "guest" });
+ * unwrapOr(fromNullable(user), { name: "guest" });
  * ```
  */
-declare const getOrElse: <T>(maybe: Maybe<T>, defaultValue: T) => T;
-/** Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. */
 declare const unwrapOr: <T>(maybe: Maybe<T>, defaultValue: T) => T;
 /**
- * Unwraps the `Some` value or throws if the value is `None`. Use in tests
- * or at the boundary of an assertion; prefer `match` / `getOrElse` in
- * production code paths.
+ * Returns the `Some` value, or `defaultValue` when the value is `None`.
+ *
+ * @deprecated Use canonical {@link unwrapOr} instead.
+ */
+declare const getOrElse: <T>(maybe: Maybe<T>, defaultValue: T) => T;
+/**
+ * Unwraps the `Some` value or throws if the value is `None`.
+ *
+ * @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.
+ * Allowed in `*.spec.ts` / `*.test.ts`; flagged elsewhere by the plugins.
  *
  * @example
  * ```ts

package/dist/index.js CHANGED Viewed

@@ -25,8 +25,8 @@ function match(...args) {
   return (maybe) => matchImpl(maybe, onSome, onNone);
 }
 var matchMaybe = match;
-var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
-var unwrapOr = getOrElse;
+var unwrapOr = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
+var getOrElse = unwrapOr;
 var unwrap = (maybe) => {
   if (isNone(maybe)) {
     throw new Error("Called unwrap on None");

package/dist/index.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/maybe.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/* Fantasy Land `of` — alias of {@link some}. /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/* Collision-free alias — mirrors `matchResult` on `@onrails/result`. /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * getOrElse(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const getOrElse = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/* Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. /\nexport const unwrapOr = getOrElse;\n\n/\n Unwraps the `Some` value or throws if the value is `None`. Use in tests\n * or at the boundary of an assertion; prefer `match` / `getOrElse` in\n * production code paths.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n"]}
1	+ {"version":3,"sources":["../src/maybe.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/\n Fantasy Land `of` — alias of {@link some}.\n * @deprecated Use {@link some} instead.\n /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/\n Collision-free alias — mirrors `matchResult` on `@onrails/result`.\n * @deprecated Namespace import carriers (e.g., `import * as Maybe from \"@onrails/maybe\"`) and use canonical {@link match} instead.\n /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * unwrapOr(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const unwrapOr = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @deprecated Use canonical {@link unwrapOr} instead.\n /\nexport const getOrElse = unwrapOr;\n\n/\n Unwraps the `Some` value or throws if the value is `None`.\n \n @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.\n * Allowed in `.spec.ts` / `.test.ts`; flagged elsewhere by the plugins.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n */\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n"]}

package/dist/interop.cjs.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/maybe.ts","../src/interop.ts"],"names":["ok","err","result","isOk"],"mappings":";;;;;;;AAYO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAa/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAiBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;ACjDjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAGnD,IAAM,QAAA,GAAW,CAAO,KAAA,EAAiB,MAAA,KAC9C,MAAA,CAAO,KAAK,CAAA,GAAIA,SAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAIC,UAAA,CAAI,QAAQ;AAGzC,IAAM,UAAA,GAAa,CAAOC,QAAA,KAC/BC,WAAA,CAAKD,QAAM,IAAI,IAAA,CAAKA,QAAA,CAAO,KAAK,CAAA,GAAI,IAAA;AAG/B,IAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,MAAA,KACiB,SAAS,YAAA,CAAa,KAAK,GAAG,MAAM;AAGhD,IAAM,WAAA,GAAc,CAACA,QAAA,KAC1B,CAACC,YAAKD,QAAM,CAAA,IAAK,gBAAA,CAAiBA,QAAA,CAAO,KAAK;AAEhD,IAAM,gBAAA,GAAmB,CAAC,KAAA,KACxB,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,MAAA,IAAU,KAAA,IACT,KAAA,CAA4B,IAAA,KAAS,MAAA","file":"interop.cjs","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/* Fantasy Land `of` — alias of {@link some}. /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/* Collision-free alias — mirrors `matchResult` on `@onrails/result`. /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * getOrElse(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const getOrElse = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/* Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. /\nexport const unwrapOr = getOrElse;\n\n/\n Unwraps the `Some` value or throws if the value is `None`. Use in tests\n * or at the boundary of an assertion; prefer `match` / `getOrElse` in\n * production code paths.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n /\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { fromNullable, isSome, type Maybe, none, some } from \"./maybe.js\";\n\n/* Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. /\nexport type NoneError = { readonly _tag: \"None\" };\n\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\n/* Lift absence into a domain error. /\nexport const toResult = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n isSome(maybe) ? ok(maybe.value) : err(onNone());\n\n/* Ok values become Some; any Err becomes None (errors are not absence). /\nexport const fromResult = <T, E>(result: Result<T, E>): Maybe<T> =>\n isOk(result) ? some(result.value) : none<T>();\n\n/* Nullable edge → Maybe; explicit None error at the boundary. /\nexport const nullableToResult = <T, E>(\n value: T \| null \| undefined,\n onNone: () => E,\n): Result<T, E> => toResult(fromNullable(value), onNone);\n\n/* True when a Result failed specifically with {@link NoneError}. */\nexport const isNoneError = (result: Result<unknown, unknown>): result is Result<never, NoneError> =>\n !isOk(result) && isNoneErrorValue(result.error);\n\nconst isNoneErrorValue = (error: unknown): error is NoneError =>\n typeof error === \"object\" &&\n error !== null &&\n \"_tag\" in error &&\n (error as { _tag: unknown })._tag === \"None\";\n"]}
1	+ {"version":3,"sources":["../src/maybe.ts","../src/interop.ts"],"names":["ok","err","result","isOk"],"mappings":";;;;;;;AAYO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAgB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAiBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;ACpDjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAGnD,IAAM,QAAA,GAAW,CAAO,KAAA,EAAiB,MAAA,KAC9C,MAAA,CAAO,KAAK,CAAA,GAAIA,SAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAIC,UAAA,CAAI,QAAQ;AAGzC,IAAM,UAAA,GAAa,CAAOC,QAAA,KAC/BC,WAAA,CAAKD,QAAM,IAAI,IAAA,CAAKA,QAAA,CAAO,KAAK,CAAA,GAAI,IAAA;AAG/B,IAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,MAAA,KACiB,SAAS,YAAA,CAAa,KAAK,GAAG,MAAM;AAGhD,IAAM,WAAA,GAAc,CAACA,QAAA,KAC1B,CAACC,YAAKD,QAAM,CAAA,IAAK,gBAAA,CAAiBA,QAAA,CAAO,KAAK;AAEhD,IAAM,gBAAA,GAAmB,CAAC,KAAA,KACxB,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,MAAA,IAAU,KAAA,IACT,KAAA,CAA4B,IAAA,KAAS,MAAA","file":"interop.cjs","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/\n Fantasy Land `of` — alias of {@link some}.\n * @deprecated Use {@link some} instead.\n /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/\n Collision-free alias — mirrors `matchResult` on `@onrails/result`.\n * @deprecated Namespace import carriers (e.g., `import * as Maybe from \"@onrails/maybe\"`) and use canonical {@link match} instead.\n /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * unwrapOr(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const unwrapOr = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @deprecated Use canonical {@link unwrapOr} instead.\n /\nexport const getOrElse = unwrapOr;\n\n/\n Unwraps the `Some` value or throws if the value is `None`.\n \n @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.\n * Allowed in `.spec.ts` / `.test.ts`; flagged elsewhere by the plugins.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n /\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { fromNullable, isSome, type Maybe, none, some } from \"./maybe.js\";\n\n/* Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. /\nexport type NoneError = { readonly _tag: \"None\" };\n\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\n/* Lift absence into a domain error. /\nexport const toResult = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n isSome(maybe) ? ok(maybe.value) : err(onNone());\n\n/* Ok values become Some; any Err becomes None (errors are not absence). /\nexport const fromResult = <T, E>(result: Result<T, E>): Maybe<T> =>\n isOk(result) ? some(result.value) : none<T>();\n\n/* Nullable edge → Maybe; explicit None error at the boundary. /\nexport const nullableToResult = <T, E>(\n value: T \| null \| undefined,\n onNone: () => E,\n): Result<T, E> => toResult(fromNullable(value), onNone);\n\n/* True when a Result failed specifically with {@link NoneError}. */\nexport const isNoneError = (result: Result<unknown, unknown>): result is Result<never, NoneError> =>\n !isOk(result) && isNoneErrorValue(result.error);\n\nconst isNoneErrorValue = (error: unknown): error is NoneError =>\n typeof error === \"object\" &&\n error !== null &&\n \"_tag\" in error &&\n (error as { _tag: unknown })._tag === \"None\";\n"]}

package/dist/interop.js.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"sources":["../src/maybe.ts","../src/interop.ts"],"names":[],"mappings":";;;;;AAYO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAa/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAiBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;ACjDjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAGnD,IAAM,QAAA,GAAW,CAAO,KAAA,EAAiB,MAAA,KAC9C,MAAA,CAAO,KAAK,CAAA,GAAI,EAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAI,GAAA,CAAI,QAAQ;AAGzC,IAAM,UAAA,GAAa,CAAO,MAAA,KAC/B,IAAA,CAAK,MAAM,IAAI,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA,GAAI,IAAA;AAG/B,IAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,MAAA,KACiB,SAAS,YAAA,CAAa,KAAK,GAAG,MAAM;AAGhD,IAAM,WAAA,GAAc,CAAC,MAAA,KAC1B,CAAC,KAAK,MAAM,CAAA,IAAK,gBAAA,CAAiB,MAAA,CAAO,KAAK;AAEhD,IAAM,gBAAA,GAAmB,CAAC,KAAA,KACxB,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,MAAA,IAAU,KAAA,IACT,KAAA,CAA4B,IAAA,KAAS,MAAA","file":"interop.js","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/* Fantasy Land `of` — alias of {@link some}. /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/* Collision-free alias — mirrors `matchResult` on `@onrails/result`. /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * getOrElse(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const getOrElse = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/* Alias — mirrors `@onrails/result` `unwrapOr`. Same as {@link getOrElse}. /\nexport const unwrapOr = getOrElse;\n\n/\n Unwraps the `Some` value or throws if the value is `None`. Use in tests\n * or at the boundary of an assertion; prefer `match` / `getOrElse` in\n * production code paths.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n /\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { fromNullable, isSome, type Maybe, none, some } from \"./maybe.js\";\n\n/* Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. /\nexport type NoneError = { readonly _tag: \"None\" };\n\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\n/* Lift absence into a domain error. /\nexport const toResult = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n isSome(maybe) ? ok(maybe.value) : err(onNone());\n\n/* Ok values become Some; any Err becomes None (errors are not absence). /\nexport const fromResult = <T, E>(result: Result<T, E>): Maybe<T> =>\n isOk(result) ? some(result.value) : none<T>();\n\n/* Nullable edge → Maybe; explicit None error at the boundary. /\nexport const nullableToResult = <T, E>(\n value: T \| null \| undefined,\n onNone: () => E,\n): Result<T, E> => toResult(fromNullable(value), onNone);\n\n/* True when a Result failed specifically with {@link NoneError}. */\nexport const isNoneError = (result: Result<unknown, unknown>): result is Result<never, NoneError> =>\n !isOk(result) && isNoneErrorValue(result.error);\n\nconst isNoneErrorValue = (error: unknown): error is NoneError =>\n typeof error === \"object\" &&\n error !== null &&\n \"_tag\" in error &&\n (error as { _tag: unknown })._tag === \"None\";\n"]}
1	+ {"version":3,"sources":["../src/maybe.ts","../src/interop.ts"],"names":[],"mappings":";;;;;AAYO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAgB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAiBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;ACpDjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAGnD,IAAM,QAAA,GAAW,CAAO,KAAA,EAAiB,MAAA,KAC9C,MAAA,CAAO,KAAK,CAAA,GAAI,EAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAI,GAAA,CAAI,QAAQ;AAGzC,IAAM,UAAA,GAAa,CAAO,MAAA,KAC/B,IAAA,CAAK,MAAM,IAAI,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA,GAAI,IAAA;AAG/B,IAAM,gBAAA,GAAmB,CAC9B,KAAA,EACA,MAAA,KACiB,SAAS,YAAA,CAAa,KAAK,GAAG,MAAM;AAGhD,IAAM,WAAA,GAAc,CAAC,MAAA,KAC1B,CAAC,KAAK,MAAM,CAAA,IAAK,gBAAA,CAAiB,MAAA,CAAO,KAAK;AAEhD,IAAM,gBAAA,GAAmB,CAAC,KAAA,KACxB,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,MAAA,IAAU,KAAA,IACT,KAAA,CAA4B,IAAA,KAAS,MAAA","file":"interop.js","sourcesContent":["import type { Maybe, None, Some } from \"./types.js\";\n\nexport type { Maybe, None, Some } from \"./types.js\";\n\n/*\n Lifts a value into the `Some` branch.\n \n @example\n * ```ts\n * const m = some(1); // Maybe<number>\n * ```\n /\nexport const some = <T>(value: T): Maybe<T> => ({ _tag: \"Some\", value });\n\n/\n Fantasy Land `of` — alias of {@link some}.\n * @deprecated Use {@link some} instead.\n /\nexport const of = some;\n\n/\n The `None` value — represents expected absence. Not a failure.\n \n @example\n * ```ts\n * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();\n * ```\n /\nexport const none = <T = never>(): Maybe<T> => ({ _tag: \"None\" });\n\n/\n Type-narrowing predicate: returns `true` when the value is `Some`.\n \n @example\n * ```ts\n * if (isSome(m)) {\n * console.log(m.value); // narrowed to Some branch\n * }\n * ```\n /\nexport const isSome = <T>(maybe: Maybe<T>): maybe is Some<T> => maybe._tag === \"Some\";\n\n/\n Type-narrowing predicate: returns `true` when the value is `None`.\n /\nexport const isNone = <T>(maybe: Maybe<T>): maybe is None => maybe._tag === \"None\";\n\n/\n Lift a nullable value into `Maybe<T>` — `null` and `undefined` become\n * `None`; anything else becomes `Some`.\n \n @example\n * ```ts\n * fromNullable(map.get(key)); // Maybe<V>\n * fromNullable(null); // None\n * ```\n /\nexport const fromNullable = <T>(value: T \| null \| undefined): Maybe<T> =>\n value == null ? none<T>() : some(value);\n\n// ─────────────────────────────────────────────────────────────────────────────\n// Dual-form helpers — each accepts either shape:\n// data-first: `map(maybe, fn)`\n// curried: `map(fn)(maybe)`\n// ─────────────────────────────────────────────────────────────────────────────\n\nconst mapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U> =>\n isSome(maybe) ? some(fn(maybe.value)) : none<U>();\n\n/\n Transform the `Some` value, passing `None` through unchanged. Dual-form.\n \n @example\n * ```ts\n * map(some(2), (n) => n * 3); // Some 6 — data-first\n * pipe(fromNullable(input), map((s) => s.trim())); // curried\n * ```\n /\nexport function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\nexport function map<T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\nexport function map(\n ...args: [Maybe<unknown>, (value: unknown) => unknown] \| [(value: unknown) => unknown]\n): unknown {\n if (args.length === 2) return mapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => mapImpl(maybe, fn);\n}\n\nconst flatMapImpl = <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U> =>\n isSome(maybe) ? fn(maybe.value) : none<U>();\n\n/\n Canonical bind for `Maybe`. Chains a `Maybe`-returning step;\n * short-circuits on `None`. Dual-form.\n \n @example\n * ```ts\n * flatMap(fromNullable(user), (u) =>\n * u.active ? some(u) : none(),\n * );\n * ```\n /\nexport function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\nexport function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\nexport function flatMap(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => Maybe<unknown>]\n \| [(value: unknown) => Maybe<unknown>]\n): unknown {\n if (args.length === 2) return flatMapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => flatMapImpl(maybe, fn);\n}\n\n/* Alias for {@link flatMap} — same dual-form shape. /\nexport const andThen = flatMap;\n\nconst matchImpl = <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U =>\n isSome(maybe) ? onSome(maybe.value) : onNone();\n\n/\n Terminal collapse — fold both branches into a single value. Positional,\n * dual-form. Same shape as `Result.match` for sibling consistency.\n \n For files that also import `match` from `ts-pattern`, the alias\n * {@link matchMaybe} is identical.\n \n @example\n * ```ts\n * const greeting = match(\n * fromNullable(user),\n * (u) => `hello ${u.name}`,\n * () => \"hello guest\",\n * );\n * ```\n /\nexport function match<T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\nexport function match<T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\nexport function match(\n ...args:\n \| [Maybe<unknown>, (value: unknown) => unknown, () => unknown]\n \| [(value: unknown) => unknown, () => unknown]\n): unknown {\n if (args.length === 3) return matchImpl(args[0], args[1], args[2]);\n const [onSome, onNone] = args;\n return (maybe: Maybe<unknown>) => matchImpl(maybe, onSome, onNone);\n}\n\n/\n Collision-free alias — mirrors `matchResult` on `@onrails/result`.\n * @deprecated Namespace import carriers (e.g., `import * as Maybe from \"@onrails/maybe\"`) and use canonical {@link match} instead.\n /\nexport const matchMaybe = match;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @example\n * ```ts\n * unwrapOr(fromNullable(user), { name: \"guest\" });\n * ```\n /\nexport const unwrapOr = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n isSome(maybe) ? maybe.value : defaultValue;\n\n/\n Returns the `Some` value, or `defaultValue` when the value is `None`.\n \n @deprecated Use canonical {@link unwrapOr} instead.\n /\nexport const getOrElse = unwrapOr;\n\n/\n Unwraps the `Some` value or throws if the value is `None`.\n \n @throws when the value is None — assertion-tier; use {@link match} / {@link unwrapOr} in business logic.\n * Allowed in `.spec.ts` / `.test.ts`; flagged elsewhere by the plugins.\n \n @example\n * ```ts\n * expect(unwrap(parseUser(raw))).toEqual(expected);\n * ```\n /\nexport const unwrap = <T>(maybe: Maybe<T>): T => {\n if (isNone(maybe)) {\n throw new Error(\"Called unwrap on None\");\n }\n return maybe.value;\n};\n\n/\n Drop every `None` and collect the remaining `Some` values into an array.\n \n @example\n * ```ts\n * compact([some(1), none(), some(2)]); // [1, 2]\n * ```\n /\nexport const compact = <T>(maybes: readonly Maybe<T>[]): T[] => {\n const out: T[] = [];\n for (const m of maybes) {\n if (isSome(m)) {\n out.push(m.value);\n }\n }\n return out;\n};\n\n/\n `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,\n * collect the rest.\n \n @example\n * ```ts\n * compactMap(rawRows, (row) =>\n * row.deletedAt ? none() : some(row.id),\n * );\n * // string[]\n * ```\n /\nexport const compactMap = <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>): U[] =>\n compact(items.map(fn));\n\n/\n `flatMap(fromNullable(value), fn)` — lift a nullable then bind through\n * a `Maybe`-returning step. Convenient for chaining lookups.\n \n @example\n * ```ts\n * optional(rawId, (id) => fromNullable(cache.get(id)));\n * ```\n /\nexport const optional = <T, U>(value: T \| null \| undefined, fn: (value: T) => Maybe<U>): Maybe<U> =>\n flatMapImpl(fromNullable(value), fn);\n\nconst tapImpl = <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T> => {\n if (isSome(maybe)) fn(maybe.value);\n return maybe;\n};\n\n/\n Run a side effect on the `Some` value, pass the `Maybe` through unchanged.\n * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.\n \n @example\n * ```ts\n * tap(some(2), (n) => console.log(n)); // logs 2, returns Some 2\n * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some\n * ```\n /\nexport function tap<T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\nexport function tap<T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tap(\n ...args: [Maybe<unknown>, (value: unknown) => void] \| [(value: unknown) => void]\n): unknown {\n if (args.length === 2) return tapImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapImpl(maybe, fn);\n}\n\nconst tapNoneImpl = <T>(maybe: Maybe<T>, fn: () => void): Maybe<T> => {\n if (isNone(maybe)) fn();\n return maybe;\n};\n\n/\n Run a side effect when the `Maybe` is `None`, pass it through unchanged.\n * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.\n \n @example\n * ```ts\n * tapNone(none(), () => metrics.miss()); // runs effect, returns None\n * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried\n * ```\n /\nexport function tapNone<T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\nexport function tapNone<T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\nexport function tapNone(...args: [Maybe<unknown>, () => void] \| [() => void]): unknown {\n if (args.length === 2) return tapNoneImpl(args[0], args[1]);\n const fn = args[0];\n return (maybe: Maybe<unknown>) => tapNoneImpl(maybe, fn);\n}\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { fromNullable, isSome, type Maybe, none, some } from \"./maybe.js\";\n\n/* Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. /\nexport type NoneError = { readonly _tag: \"None\" };\n\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\n/* Lift absence into a domain error. /\nexport const toResult = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n isSome(maybe) ? ok(maybe.value) : err(onNone());\n\n/* Ok values become Some; any Err becomes None (errors are not absence). /\nexport const fromResult = <T, E>(result: Result<T, E>): Maybe<T> =>\n isOk(result) ? some(result.value) : none<T>();\n\n/* Nullable edge → Maybe; explicit None error at the boundary. /\nexport const nullableToResult = <T, E>(\n value: T \| null \| undefined,\n onNone: () => E,\n): Result<T, E> => toResult(fromNullable(value), onNone);\n\n/* True when a Result failed specifically with {@link NoneError}. */\nexport const isNoneError = (result: Result<unknown, unknown>): result is Result<never, NoneError> =>\n !isOk(result) && isNoneErrorValue(result.error);\n\nconst isNoneErrorValue = (error: unknown): error is NoneError =>\n typeof error === \"object\" &&\n error !== null &&\n \"_tag\" in error &&\n (error as { _tag: unknown })._tag === \"None\";\n"]}

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@onrails/maybe",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Tagged Maybe for expected absence — pure tagged unions, Result interop, tree-shakeable",
   "license": "MIT",
   "author": "Alan R. Soares",