@onrails/maybe 0.2.2 → 0.2.5

package/dist/index.d.ts

@@ -1,244 +1,2 @@
-/**
- * Tagged optional value — a discriminated union over `_tag` where absence
- * (`None`) is an expected outcome, not a failure. Construct with {@link some} /
- * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with
- * {@link match}.
- *
- * @example
- * ```ts
- * function findUser(id: string): Maybe<User> {
- *   return fromNullable(db.users.get(id));
- * }
- * ```
- */
-type Maybe<T> = {
-    readonly _tag: "Some";
-    readonly value: T;
-} | {
-    readonly _tag: "None";
-};
-/** The `Some` branch of a {@link Maybe} — a present value tagged `"Some"`. */
-type Some<T> = Extract<Maybe<T>, {
-    _tag: "Some";
-}>;
-/** The `None` branch of a {@link Maybe} — expected absence, tagged `"None"`. */
-type None = Extract<Maybe<never>, {
-    _tag: "None";
-}>;
-/**
- * Lifts a value into the `Some` branch.
- *
- * @example
- * ```ts
- * const m = some(1);   // Maybe<number>
- * ```
- */
-declare const some: <T>(value: T) => Maybe<T>;
-/**
- * Fantasy Land `pure` — alias of {@link some}. One lift name shared across
- * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style
- * code.
- *
- * @example
- * ```ts
- * const m = of(1);   // Maybe<number> — identical to some(1)
- * ```
- */
-declare const of: <T>(value: T) => Maybe<T>;
-/**
- * The `None` value — represents expected absence. Not a failure.
- *
- * @example
- * ```ts
- * const cached: Maybe<User> = cache.has(id) ? some(cache.get(id)) : none();
- * ```
- */
-declare const none: <T = never>() => Maybe<T>;
-/**
- * Type-narrowing predicate: returns `true` when the value is `Some`.
- *
- * @example
- * ```ts
- * if (isSome(m)) {
- *   console.log(m.value);   // narrowed to Some branch
- * }
- * ```
- */
-declare const isSome: <T>(maybe: Maybe<T>) => maybe is Some<T>;
-/**
- * Type-narrowing predicate: returns `true` when the value is `None`.
- *
- * @example
- * ```ts
- * if (isNone(fromNullable(user))) {
- *   return redirect("/login");   // narrowed to None branch
- * }
- * ```
- */
-declare const isNone: <T>(maybe: Maybe<T>) => maybe is None;
-/**
- * Lift a nullable value into `Maybe<T>` — `null` and `undefined` become
- * `None`; anything else becomes `Some`.
- *
- * @example
- * ```ts
- * fromNullable(cache.get(key));   // Maybe<V>
- * fromNullable(null);             // None
- * ```
- */
-declare const fromNullable: <T>(value: T | null | undefined) => Maybe<T>;
-/**
- * Transform the `Some` value, passing `None` through unchanged. Dual-form.
- *
- * @example
- * ```ts
- * map(some(2), (n) => n * 3);                      // Some 6 — data-first
- * pipe(fromNullable(input), map((s) => s.trim())); // curried
- * ```
- */
-declare const map: {
-    <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;
-    <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;
-};
-/**
- * Canonical bind for `Maybe`. Chains a `Maybe`-returning step;
- * short-circuits on `None`. Dual-form.
- *
- * @example
- * ```ts
- * flatMap(fromNullable(user), (u) =>
- *   u.active ? some(u) : none(),
- * );
- * ```
- */
-declare const flatMap: {
-    <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;
-    <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;
-};
-/**
- * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer
- * {@link flatMap} as the canonical name; reach for `andThen` only when porting
- * neverthrow code or matching its vocabulary.
- *
- * @example
- * ```ts
- * andThen(fromNullable(user), (u) =>
- *   u.active ? some(u) : none(),
- * );
- * ```
- */
-declare const andThen: {
-    <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;
-    <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;
-};
-/**
- * Terminal collapse — fold both branches into a single value. Positional,
- * dual-form. Same shape as `Result.match` for sibling consistency.
- *
- * For files that also import `match` from `ts-pattern`, use a namespace
- * import (`import * as Maybe from "@onrails/maybe"` → `Maybe.match`) to
- * dissolve the collision.
- *
- * @example
- * ```ts
- * const greeting = match(
- *   fromNullable(user),
- *   (u) => `hello ${u.name}`,
- *   () => "hello guest",
- * );
- * ```
- */
-declare const match: {
-    <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;
-    <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;
-};
-declare const unwrapOr: {
-    <T>(maybe: Maybe<T>, defaultValue: T): T;
-    <T>(defaultValue: T): (maybe: Maybe<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
- * expect(unwrap(parseUser(raw))).toEqual(expected);
- * ```
- */
-declare const unwrap: <T>(maybe: Maybe<T>) => T;
-/**
- * Drop every `None` and collect the remaining `Some` values into an array.
- *
- * @example
- * ```ts
- * compact([some(1), none(), some(2)]);    // [1, 2]
- * ```
- */
-declare const compact: <T>(maybes: readonly Maybe<T>[]) => T[];
-/**
- * `compact(items.map(fn))` — map each item to `Maybe`, drop `None`,
- * collect the rest.
- *
- * @example
- * ```ts
- * compactMap(rawRows, (row) =>
- *   row.deletedAt ? none() : some(row.id),
- * );
- * // string[]
- * ```
- */
-declare const compactMap: <T, U>(items: readonly T[], fn: (item: T) => Maybe<U>) => U[];
-/**
- * `flatMap(fromNullable(value), fn)` — lift a nullable then bind through
- * a `Maybe`-returning step. Convenient for chaining lookups.
- *
- * @example
- * ```ts
- * optional(rawId, (id) => fromNullable(cache.get(id)));
- * ```
- */
-declare const optional: <T, U>(value: T | null | undefined, fn: (value: T) => Maybe<U>) => Maybe<U>;
-/**
- * Run a side effect on the `Some` value, pass the `Maybe` through unchanged.
- * `None` is a no-op. Mirrors `tap` from `@onrails/result`. Dual-form.
- *
- * @example
- * ```ts
- * tap(some(2), (n) => console.log(n));               // logs 2, returns Some 2
- * pipe(fromNullable(row), tap((r) => sink.push(r))); // curried — collect on Some
- * ```
- */
-declare const tap: {
-    <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;
-    <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;
-};
-/**
- * Run a side effect when the `Maybe` is `None`, pass it through unchanged.
- * `Some` is a no-op. The `None`-side mirror of {@link tap}. Dual-form.
- *
- * @example
- * ```ts
- * tapNone(none(), () => metrics.miss());              // runs effect, returns None
- * pipe(fromNullable(hit), tapNone(() => metrics.miss())); // curried
- * ```
- */
-declare const tapNone: {
-    <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;
-    <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;
-};
-/**
- * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads
- * print as JSON (values are plain data by design); non-JSON payloads fall
- * back to `String(...)`. Mirror of the result package's `show`.
- *
- * @example
- * ```ts
- * show(some(1));   // 'Some(1)'
- * show(none());    // 'None'
- * ```
- */
-declare const show: <T>(maybe: Maybe<T>) => string;
-
-export { type Maybe, type None, type Some, andThen, compact, compactMap, flatMap, fromNullable, isNone, isSome, map, match, none, of, optional, show, some, tap, tapNone, unwrap, unwrapOr };
+export type { Maybe, None, Some } from "./maybe.js";
+export { andThen, compact, compactMap, flatMap, fromNullable, isNone, isSome, map, match, none, of, optional, show, some, tap, tapNone, unwrap, unwrapOr, } from "./maybe.js";

package/dist/index.js

@@ -1,9 +1,6 @@
 // src/internal/dual.ts
 function dual(arity, body) {
-  const dispatch = (...args) => {
-    if (args.length >= arity) return body(...args);
-    return (self) => body(self, ...args);
-  };
+  const dispatch = (...args) => args.length >= arity ? body(...args) : (self) => body(self, ...args);
   return dispatch;
 }
 

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/internal/dual.ts","../src/maybe.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Owning module for the dual-form call idiom used across `@onrails/maybe`:\n * a function accepts either data-first (`map(m, fn)`) or curried data-last\n * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed\n * `arity`.\n *\n * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep\n * the two in sync. No cross-package imports are allowed in this repo, so the\n * helper is vendored independently in each package rather than shared.\n */\nexport function dual<F>(arity: number, body: (...args: never[]) => unknown): F {\n  const dispatch = (...args: unknown[]): unknown => {\n    if (args.length >= arity) return (body as (...a: unknown[]) => unknown)(...args);\n    return (self: unknown) => (body as (...a: unknown[]) => unknown)(self, ...args);\n  };\n  // cast: the caller's overloaded type annotation supplies the real signature\n  return dispatch as F;\n}\n","import { dual } from \"./internal/dual.js\";\n\n/**\n * Tagged optional value — a discriminated union over `_tag` where absence\n * (`None`) is an expected outcome, not a failure. Construct with {@link some} /\n * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with\n * {@link match}.\n *\n * @example\n * ```ts\n * function findUser(id: string): Maybe<User> {\n *   return fromNullable(db.users.get(id));\n * }\n * ```\n */\nexport type Maybe<T> = { readonly _tag: \"Some\"; readonly value: T } | { readonly _tag: \"None\" };\n\n/** The `Some` branch of a {@link Maybe} — a present value tagged `\"Some\"`. */\nexport type Some<T> = Extract<Maybe<T>, { _tag: \"Some\" }>;\n\n/** The `None` branch of a {@link Maybe} — expected absence, tagged `\"None\"`. */\nexport type None = Extract<Maybe<never>, { _tag: \"None\" }>;\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 `pure` — alias of {@link some}. One lift name shared across\n * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style\n * code.\n *\n * @example\n * ```ts\n * const m = of(1);   // Maybe<number> — identical to some(1)\n * ```\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 *\n * @example\n * ```ts\n * if (isNone(fromNullable(user))) {\n *   return redirect(\"/login\");   // narrowed to None branch\n * }\n * ```\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(cache.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 const map: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\n  <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, mapImpl);\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 const flatMap: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\n  <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, flatMapImpl);\n\n/**\n * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer\n * {@link flatMap} as the canonical name; reach for `andThen` only when porting\n * neverthrow code or matching its vocabulary.\n *\n * @example\n * ```ts\n * andThen(fromNullable(user), (u) =>\n *   u.active ? some(u) : none(),\n * );\n * ```\n */\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`, use a namespace\n * import (`import * as Maybe from \"@onrails/maybe\"` → `Maybe.match`) to\n * dissolve the collision.\n *\n * @example\n * ```ts\n * const greeting = match(\n *   fromNullable(user),\n *   (u) => `hello ${u.name}`,\n *   () => \"hello guest\",\n * );\n * ```\n */\nexport const match: {\n  <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\n  <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\n} = dual(3, matchImpl);\n\nconst unwrapOrImpl = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n  isSome(maybe) ? maybe.value : defaultValue;\n\nexport const unwrapOr: {\n  <T>(maybe: Maybe<T>, defaultValue: T): T;\n  <T>(defaultValue: T): (maybe: Maybe<T>) => T;\n} = dual(2, unwrapOrImpl);\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 const tap: {\n  <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\n  <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapImpl);\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 const tapNone: {\n  <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\n  <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapNoneImpl);\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`. Mirror of the result package's `show`.\n *\n * @example\n * ```ts\n * show(some(1));   // 'Some(1)'\n * show(none());    // 'None'\n * ```\n */\nexport const show = <T>(maybe: Maybe<T>): string =>\n  isSome(maybe) ? `Some(${printPayload(maybe.value)})` : \"None\";\n"]}
+{"version":3,"sources":["../src/internal/dual.ts","../src/maybe.ts"],"names":[],"mappings":"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","file":"index.js","sourcesContent":["/**\n * Owning module for the dual-form call idiom used across `@onrails/maybe`:\n * a function accepts either data-first (`map(m, fn)`) or curried data-last\n * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed\n * `arity`.\n *\n * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep\n * the two in sync. No cross-package imports are allowed in this repo, so the\n * helper is vendored independently in each package rather than shared.\n */\nexport function dual<F>(arity: number, body: (...args: never[]) => unknown): F {\n  const dispatch = (...args: unknown[]): unknown =>\n    args.length >= arity\n      ? (body as (...a: unknown[]) => unknown)(...args)\n      : (self: unknown) => (body as (...a: unknown[]) => unknown)(self, ...args);\n  // cast: the caller's overloaded type annotation supplies the real signature\n  return dispatch as F;\n}\n","import { dual } from \"./internal/dual.js\";\n\n/**\n * Tagged optional value — a discriminated union over `_tag` where absence\n * (`None`) is an expected outcome, not a failure. Construct with {@link some} /\n * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with\n * {@link match}.\n *\n * @example\n * ```ts\n * function findUser(id: string): Maybe<User> {\n *   return fromNullable(db.users.get(id));\n * }\n * ```\n */\nexport type Maybe<T> = { readonly _tag: \"Some\"; readonly value: T } | { readonly _tag: \"None\" };\n\n/** The `Some` branch of a {@link Maybe} — a present value tagged `\"Some\"`. */\nexport type Some<T> = Extract<Maybe<T>, { _tag: \"Some\" }>;\n\n/** The `None` branch of a {@link Maybe} — expected absence, tagged `\"None\"`. */\nexport type None = Extract<Maybe<never>, { _tag: \"None\" }>;\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 `pure` — alias of {@link some}. One lift name shared across\n * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style\n * code.\n *\n * @example\n * ```ts\n * const m = of(1);   // Maybe<number> — identical to some(1)\n * ```\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 *\n * @example\n * ```ts\n * if (isNone(fromNullable(user))) {\n *   return redirect(\"/login\");   // narrowed to None branch\n * }\n * ```\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(cache.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 const map: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\n  <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, mapImpl);\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 const flatMap: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\n  <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, flatMapImpl);\n\n/**\n * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer\n * {@link flatMap} as the canonical name; reach for `andThen` only when porting\n * neverthrow code or matching its vocabulary.\n *\n * @example\n * ```ts\n * andThen(fromNullable(user), (u) =>\n *   u.active ? some(u) : none(),\n * );\n * ```\n */\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`, use a namespace\n * import (`import * as Maybe from \"@onrails/maybe\"` → `Maybe.match`) to\n * dissolve the collision.\n *\n * @example\n * ```ts\n * const greeting = match(\n *   fromNullable(user),\n *   (u) => `hello ${u.name}`,\n *   () => \"hello guest\",\n * );\n * ```\n */\nexport const match: {\n  <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\n  <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\n} = dual(3, matchImpl);\n\nconst unwrapOrImpl = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n  isSome(maybe) ? maybe.value : defaultValue;\n\nexport const unwrapOr: {\n  <T>(maybe: Maybe<T>, defaultValue: T): T;\n  <T>(defaultValue: T): (maybe: Maybe<T>) => T;\n} = dual(2, unwrapOrImpl);\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 const tap: {\n  <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\n  <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapImpl);\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 const tapNone: {\n  <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\n  <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapNoneImpl);\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`. Mirror of the result package's `show`.\n *\n * @example\n * ```ts\n * show(some(1));   // 'Some(1)'\n * show(none());    // 'None'\n * ```\n */\nexport const show = <T>(maybe: Maybe<T>): string =>\n  isSome(maybe) ? `Some(${printPayload(maybe.value)})` : \"None\";\n"]}

package/dist/internal/dual.d.cts

@@ -0,0 +1,11 @@
+/**
+ * Owning module for the dual-form call idiom used across `@onrails/maybe`:
+ * a function accepts either data-first (`map(m, fn)`) or curried data-last
+ * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed
+ * `arity`.
+ *
+ * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep
+ * the two in sync. No cross-package imports are allowed in this repo, so the
+ * helper is vendored independently in each package rather than shared.
+ */
+export declare function dual<F>(arity: number, body: (...args: never[]) => unknown): F;

package/dist/internal/dual.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Owning module for the dual-form call idiom used across `@onrails/maybe`:
+ * a function accepts either data-first (`map(m, fn)`) or curried data-last
+ * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed
+ * `arity`.
+ *
+ * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep
+ * the two in sync. No cross-package imports are allowed in this repo, so the
+ * helper is vendored independently in each package rather than shared.
+ */
+export declare function dual<F>(arity: number, body: (...args: never[]) => unknown): F;

package/dist/interop.cjs

@@ -6,10 +6,7 @@ var result = require('@onrails/result');
 
 // src/internal/dual.ts
 function dual(arity, body) {
-  const dispatch = (...args) => {
-    if (args.length >= arity) return body(...args);
-    return (self) => body(self, ...args);
-  };
+  const dispatch = (...args) => args.length >= arity ? body(...args) : (self) => body(self, ...args);
   return dispatch;
 }
 

package/dist/interop.cjs.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/internal/dual.ts","../src/maybe.ts","../src/interop.ts"],"names":["ok","err","result","isOk"],"mappings":";;;;;;;AAUO,SAAS,IAAA,CAAQ,OAAe,IAAA,EAAwC;AAC7E,EAAA,MAAM,QAAA,GAAW,IAAI,IAAA,KAA6B;AAChD,IAAA,IAAI,KAAK,MAAA,IAAU,KAAA,EAAO,OAAQ,IAAA,CAAsC,GAAG,IAAI,CAAA;AAC/E,IAAA,OAAO,CAAC,IAAA,KAAmB,IAAA,CAAsC,IAAA,EAAM,GAAG,IAAI,CAAA;AAAA,EAChF,CAAA;AAEA,EAAA,OAAO,QAAA;AACT;;;ACcO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAsB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAwBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;AClFjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAE1D,IAAM,YAAA,GAAe,CAAO,KAAA,EAAiB,MAAA,KAC3C,MAAA,CAAO,KAAK,CAAA,GAAIA,SAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAIC,UAAA,CAAI,QAAQ,CAAA;AAGzC,IAAM,QAAA,GAGT,IAAA,CAAK,CAAA,EAAG,YAAY;AAExB,IAAM,cAAA,GAAiB,CAAOC,QAAA,KAC5BC,WAAA,CAAKD,QAAM,IAAI,IAAA,CAAKA,QAAA,CAAO,KAAK,CAAA,GAAI,IAAA,EAAK;AAGpC,IAAM,UAAA,GAGT,IAAA,CAAK,CAAA,EAAG,cAAc;AAE1B,IAAM,oBAAA,GAAuB,CAAO,KAAA,EAA6B,MAAA,KAC/D,aAAa,YAAA,CAAa,KAAK,GAAG,MAAM,CAAA;AAGnC,IAAM,gBAAA,GAGT,IAAA,CAAK,CAAA,EAAG,oBAAoB;AAGzB,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":["/**\n * Owning module for the dual-form call idiom used across `@onrails/maybe`:\n * a function accepts either data-first (`map(m, fn)`) or curried data-last\n * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed\n * `arity`.\n *\n * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep\n * the two in sync. No cross-package imports are allowed in this repo, so the\n * helper is vendored independently in each package rather than shared.\n */\nexport function dual<F>(arity: number, body: (...args: never[]) => unknown): F {\n  const dispatch = (...args: unknown[]): unknown => {\n    if (args.length >= arity) return (body as (...a: unknown[]) => unknown)(...args);\n    return (self: unknown) => (body as (...a: unknown[]) => unknown)(self, ...args);\n  };\n  // cast: the caller's overloaded type annotation supplies the real signature\n  return dispatch as F;\n}\n","import { dual } from \"./internal/dual.js\";\n\n/**\n * Tagged optional value — a discriminated union over `_tag` where absence\n * (`None`) is an expected outcome, not a failure. Construct with {@link some} /\n * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with\n * {@link match}.\n *\n * @example\n * ```ts\n * function findUser(id: string): Maybe<User> {\n *   return fromNullable(db.users.get(id));\n * }\n * ```\n */\nexport type Maybe<T> = { readonly _tag: \"Some\"; readonly value: T } | { readonly _tag: \"None\" };\n\n/** The `Some` branch of a {@link Maybe} — a present value tagged `\"Some\"`. */\nexport type Some<T> = Extract<Maybe<T>, { _tag: \"Some\" }>;\n\n/** The `None` branch of a {@link Maybe} — expected absence, tagged `\"None\"`. */\nexport type None = Extract<Maybe<never>, { _tag: \"None\" }>;\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 `pure` — alias of {@link some}. One lift name shared across\n * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style\n * code.\n *\n * @example\n * ```ts\n * const m = of(1);   // Maybe<number> — identical to some(1)\n * ```\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 *\n * @example\n * ```ts\n * if (isNone(fromNullable(user))) {\n *   return redirect(\"/login\");   // narrowed to None branch\n * }\n * ```\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(cache.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 const map: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\n  <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, mapImpl);\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 const flatMap: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\n  <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, flatMapImpl);\n\n/**\n * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer\n * {@link flatMap} as the canonical name; reach for `andThen` only when porting\n * neverthrow code or matching its vocabulary.\n *\n * @example\n * ```ts\n * andThen(fromNullable(user), (u) =>\n *   u.active ? some(u) : none(),\n * );\n * ```\n */\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`, use a namespace\n * import (`import * as Maybe from \"@onrails/maybe\"` → `Maybe.match`) to\n * dissolve the collision.\n *\n * @example\n * ```ts\n * const greeting = match(\n *   fromNullable(user),\n *   (u) => `hello ${u.name}`,\n *   () => \"hello guest\",\n * );\n * ```\n */\nexport const match: {\n  <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\n  <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\n} = dual(3, matchImpl);\n\nconst unwrapOrImpl = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n  isSome(maybe) ? maybe.value : defaultValue;\n\nexport const unwrapOr: {\n  <T>(maybe: Maybe<T>, defaultValue: T): T;\n  <T>(defaultValue: T): (maybe: Maybe<T>) => T;\n} = dual(2, unwrapOrImpl);\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 const tap: {\n  <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\n  <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapImpl);\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 const tapNone: {\n  <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\n  <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapNoneImpl);\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`. Mirror of the result package's `show`.\n *\n * @example\n * ```ts\n * show(some(1));   // 'Some(1)'\n * show(none());    // 'None'\n * ```\n */\nexport const show = <T>(maybe: Maybe<T>): string =>\n  isSome(maybe) ? `Some(${printPayload(maybe.value)})` : \"None\";\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { dual } from \"./internal/dual.js\";\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\n/** Construct the {@link NoneError} sentinel. */\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\nconst toResultImpl = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n  isSome(maybe) ? ok(maybe.value) : err(onNone());\n\n/** Lift absence into a domain error. */\nexport const toResult: {\n  <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(maybe: Maybe<T>) => Result<T, E>;\n} = dual(2, toResultImpl);\n\nconst fromResultImpl = <T, E>(result: Result<T, E>): Maybe<T> =>\n  isOk(result) ? some(result.value) : none();\n\n/** Ok values become Some; any Err becomes None (errors are not absence). */\nexport const fromResult: {\n  <T, E>(result: Result<T, E>): Maybe<T>;\n  <T, E>(): (result: Result<T, E>) => Maybe<T>;\n} = dual(1, fromResultImpl);\n\nconst nullableToResultImpl = <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E> =>\n  toResultImpl(fromNullable(value), onNone);\n\n/** Nullable edge → Maybe; explicit None error at the boundary. */\nexport const nullableToResult: {\n  <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(value: T | null | undefined) => Result<T, E>;\n} = dual(2, nullableToResultImpl);\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"]}
+{"version":3,"sources":["../src/internal/dual.ts","../src/maybe.ts","../src/interop.ts"],"names":["ok","err","result","isOk"],"mappings":";;;;;;;AAUO,SAAS,IAAA,CAAQ,OAAe,IAAA,EAAwC;AAC7E,EAAA,MAAM,QAAA,GAAW,CAAA,GAAI,IAAA,KACnB,IAAA,CAAK,UAAU,KAAA,GACV,IAAA,CAAsC,GAAG,IAAI,IAC9C,CAAC,IAAA,KAAmB,IAAA,CAAsC,IAAA,EAAM,GAAG,IAAI,CAAA;AAE7E,EAAA,OAAO,QAAA;AACT;;;ACcO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAsB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAwBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;AClFjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAE1D,IAAM,YAAA,GAAe,CAAO,KAAA,EAAiB,MAAA,KAC3C,MAAA,CAAO,KAAK,CAAA,GAAIA,SAAA,CAAS,KAAA,CAAM,KAAK,CAAA,GAAIC,UAAA,CAAU,QAAQ,CAAA;AAGrD,IAAM,QAAA,GAGT,IAAA,CAAK,CAAA,EAAG,YAAY;AAExB,IAAM,cAAA,GAAiB,CAAOC,QAAA,KAC5BC,WAAA,CAAKD,QAAM,IAAI,IAAA,CAAKA,QAAA,CAAO,KAAK,CAAA,GAAI,IAAA,EAAK;AAGpC,IAAM,UAAA,GAGT,IAAA,CAAK,CAAA,EAAG,cAAc;AAE1B,IAAM,oBAAA,GAAuB,CAAO,KAAA,EAA6B,MAAA,KAC/D,aAAa,YAAA,CAAa,KAAK,GAAG,MAAM,CAAA;AAGnC,IAAM,gBAAA,GAGT,IAAA,CAAK,CAAA,EAAG,oBAAoB;AAGzB,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":["/**\n * Owning module for the dual-form call idiom used across `@onrails/maybe`:\n * a function accepts either data-first (`map(m, fn)`) or curried data-last\n * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed\n * `arity`.\n *\n * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep\n * the two in sync. No cross-package imports are allowed in this repo, so the\n * helper is vendored independently in each package rather than shared.\n */\nexport function dual<F>(arity: number, body: (...args: never[]) => unknown): F {\n  const dispatch = (...args: unknown[]): unknown =>\n    args.length >= arity\n      ? (body as (...a: unknown[]) => unknown)(...args)\n      : (self: unknown) => (body as (...a: unknown[]) => unknown)(self, ...args);\n  // cast: the caller's overloaded type annotation supplies the real signature\n  return dispatch as F;\n}\n","import { dual } from \"./internal/dual.js\";\n\n/**\n * Tagged optional value — a discriminated union over `_tag` where absence\n * (`None`) is an expected outcome, not a failure. Construct with {@link some} /\n * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with\n * {@link match}.\n *\n * @example\n * ```ts\n * function findUser(id: string): Maybe<User> {\n *   return fromNullable(db.users.get(id));\n * }\n * ```\n */\nexport type Maybe<T> = { readonly _tag: \"Some\"; readonly value: T } | { readonly _tag: \"None\" };\n\n/** The `Some` branch of a {@link Maybe} — a present value tagged `\"Some\"`. */\nexport type Some<T> = Extract<Maybe<T>, { _tag: \"Some\" }>;\n\n/** The `None` branch of a {@link Maybe} — expected absence, tagged `\"None\"`. */\nexport type None = Extract<Maybe<never>, { _tag: \"None\" }>;\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 `pure` — alias of {@link some}. One lift name shared across\n * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style\n * code.\n *\n * @example\n * ```ts\n * const m = of(1);   // Maybe<number> — identical to some(1)\n * ```\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 *\n * @example\n * ```ts\n * if (isNone(fromNullable(user))) {\n *   return redirect(\"/login\");   // narrowed to None branch\n * }\n * ```\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(cache.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 const map: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\n  <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, mapImpl);\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 const flatMap: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\n  <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, flatMapImpl);\n\n/**\n * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer\n * {@link flatMap} as the canonical name; reach for `andThen` only when porting\n * neverthrow code or matching its vocabulary.\n *\n * @example\n * ```ts\n * andThen(fromNullable(user), (u) =>\n *   u.active ? some(u) : none(),\n * );\n * ```\n */\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`, use a namespace\n * import (`import * as Maybe from \"@onrails/maybe\"` → `Maybe.match`) to\n * dissolve the collision.\n *\n * @example\n * ```ts\n * const greeting = match(\n *   fromNullable(user),\n *   (u) => `hello ${u.name}`,\n *   () => \"hello guest\",\n * );\n * ```\n */\nexport const match: {\n  <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\n  <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\n} = dual(3, matchImpl);\n\nconst unwrapOrImpl = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n  isSome(maybe) ? maybe.value : defaultValue;\n\nexport const unwrapOr: {\n  <T>(maybe: Maybe<T>, defaultValue: T): T;\n  <T>(defaultValue: T): (maybe: Maybe<T>) => T;\n} = dual(2, unwrapOrImpl);\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 const tap: {\n  <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\n  <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapImpl);\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 const tapNone: {\n  <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\n  <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapNoneImpl);\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`. Mirror of the result package's `show`.\n *\n * @example\n * ```ts\n * show(some(1));   // 'Some(1)'\n * show(none());    // 'None'\n * ```\n */\nexport const show = <T>(maybe: Maybe<T>): string =>\n  isSome(maybe) ? `Some(${printPayload(maybe.value)})` : \"None\";\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { dual } from \"./internal/dual.js\";\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\n/** Construct the {@link NoneError} sentinel. */\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\nconst toResultImpl = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n  isSome(maybe) ? ok<T, E>(maybe.value) : err<T, E>(onNone());\n\n/** Lift absence into a domain error. */\nexport const toResult: {\n  <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(maybe: Maybe<T>) => Result<T, E>;\n} = dual(2, toResultImpl);\n\nconst fromResultImpl = <T, E>(result: Result<T, E>): Maybe<T> =>\n  isOk(result) ? some(result.value) : none();\n\n/** Ok values become Some; any Err becomes None (errors are not absence). */\nexport const fromResult: {\n  <T, E>(result: Result<T, E>): Maybe<T>;\n  <T, E>(): (result: Result<T, E>) => Maybe<T>;\n} = dual(1, fromResultImpl);\n\nconst nullableToResultImpl = <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E> =>\n  toResultImpl(fromNullable(value), onNone);\n\n/** Nullable edge → Maybe; explicit None error at the boundary. */\nexport const nullableToResult: {\n  <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(value: T | null | undefined) => Result<T, E>;\n} = dual(2, nullableToResultImpl);\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.d.cts

@@ -1,28 +1,25 @@
-import { Result } from '@onrails/result';
-import { Maybe } from './index.cjs';
-
+import { type Result } from "@onrails/result";
+import { type Maybe } from "./maybe.js";
 /** Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. */
-type NoneError = {
+export type NoneError = {
     readonly _tag: "None";
 };
 /** Construct the {@link NoneError} sentinel. */
-declare const noneError: () => NoneError;
+export declare const noneError: () => NoneError;
 /** Lift absence into a domain error. */
-declare const toResult: {
+export declare const toResult: {
     <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E>;
     <E>(onNone: () => E): <T>(maybe: Maybe<T>) => Result<T, E>;
 };
 /** Ok values become Some; any Err becomes None (errors are not absence). */
-declare const fromResult: {
+export declare const fromResult: {
     <T, E>(result: Result<T, E>): Maybe<T>;
     <T, E>(): (result: Result<T, E>) => Maybe<T>;
 };
 /** Nullable edge → Maybe; explicit None error at the boundary. */
-declare const nullableToResult: {
+export declare const nullableToResult: {
     <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E>;
     <E>(onNone: () => E): <T>(value: T | null | undefined) => Result<T, E>;
 };
 /** True when a Result failed specifically with {@link NoneError}. */
-declare const isNoneError: (result: Result<unknown, unknown>) => result is Result<never, NoneError>;
-
-export { type NoneError, fromResult, isNoneError, noneError, nullableToResult, toResult };
+export declare const isNoneError: (result: Result<unknown, unknown>) => result is Result<never, NoneError>;

package/dist/interop.d.ts

@@ -1,28 +1,25 @@
-import { Result } from '@onrails/result';
-import { Maybe } from './index.js';
-
+import { type Result } from "@onrails/result";
+import { type Maybe } from "./maybe.js";
 /** Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. */
-type NoneError = {
+export type NoneError = {
     readonly _tag: "None";
 };
 /** Construct the {@link NoneError} sentinel. */
-declare const noneError: () => NoneError;
+export declare const noneError: () => NoneError;
 /** Lift absence into a domain error. */
-declare const toResult: {
+export declare const toResult: {
     <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E>;
     <E>(onNone: () => E): <T>(maybe: Maybe<T>) => Result<T, E>;
 };
 /** Ok values become Some; any Err becomes None (errors are not absence). */
-declare const fromResult: {
+export declare const fromResult: {
     <T, E>(result: Result<T, E>): Maybe<T>;
     <T, E>(): (result: Result<T, E>) => Maybe<T>;
 };
 /** Nullable edge → Maybe; explicit None error at the boundary. */
-declare const nullableToResult: {
+export declare const nullableToResult: {
     <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E>;
     <E>(onNone: () => E): <T>(value: T | null | undefined) => Result<T, E>;
 };
 /** True when a Result failed specifically with {@link NoneError}. */
-declare const isNoneError: (result: Result<unknown, unknown>) => result is Result<never, NoneError>;
-
-export { type NoneError, fromResult, isNoneError, noneError, nullableToResult, toResult };
+export declare const isNoneError: (result: Result<unknown, unknown>) => result is Result<never, NoneError>;

package/dist/interop.js

@@ -4,10 +4,7 @@ import { isOk, ok, err } from '@onrails/result';
 
 // src/internal/dual.ts
 function dual(arity, body) {
-  const dispatch = (...args) => {
-    if (args.length >= arity) return body(...args);
-    return (self) => body(self, ...args);
-  };
+  const dispatch = (...args) => args.length >= arity ? body(...args) : (self) => body(self, ...args);
   return dispatch;
 }
 

package/dist/interop.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../src/internal/dual.ts","../src/maybe.ts","../src/interop.ts"],"names":[],"mappings":";;;;;AAUO,SAAS,IAAA,CAAQ,OAAe,IAAA,EAAwC;AAC7E,EAAA,MAAM,QAAA,GAAW,IAAI,IAAA,KAA6B;AAChD,IAAA,IAAI,KAAK,MAAA,IAAU,KAAA,EAAO,OAAQ,IAAA,CAAsC,GAAG,IAAI,CAAA;AAC/E,IAAA,OAAO,CAAC,IAAA,KAAmB,IAAA,CAAsC,IAAA,EAAM,GAAG,IAAI,CAAA;AAAA,EAChF,CAAA;AAEA,EAAA,OAAO,QAAA;AACT;;;ACcO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAsB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAwBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;AClFjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAE1D,IAAM,YAAA,GAAe,CAAO,KAAA,EAAiB,MAAA,KAC3C,MAAA,CAAO,KAAK,CAAA,GAAI,EAAA,CAAG,KAAA,CAAM,KAAK,CAAA,GAAI,GAAA,CAAI,QAAQ,CAAA;AAGzC,IAAM,QAAA,GAGT,IAAA,CAAK,CAAA,EAAG,YAAY;AAExB,IAAM,cAAA,GAAiB,CAAO,MAAA,KAC5B,IAAA,CAAK,MAAM,IAAI,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA,GAAI,IAAA,EAAK;AAGpC,IAAM,UAAA,GAGT,IAAA,CAAK,CAAA,EAAG,cAAc;AAE1B,IAAM,oBAAA,GAAuB,CAAO,KAAA,EAA6B,MAAA,KAC/D,aAAa,YAAA,CAAa,KAAK,GAAG,MAAM,CAAA;AAGnC,IAAM,gBAAA,GAGT,IAAA,CAAK,CAAA,EAAG,oBAAoB;AAGzB,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":["/**\n * Owning module for the dual-form call idiom used across `@onrails/maybe`:\n * a function accepts either data-first (`map(m, fn)`) or curried data-last\n * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed\n * `arity`.\n *\n * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep\n * the two in sync. No cross-package imports are allowed in this repo, so the\n * helper is vendored independently in each package rather than shared.\n */\nexport function dual<F>(arity: number, body: (...args: never[]) => unknown): F {\n  const dispatch = (...args: unknown[]): unknown => {\n    if (args.length >= arity) return (body as (...a: unknown[]) => unknown)(...args);\n    return (self: unknown) => (body as (...a: unknown[]) => unknown)(self, ...args);\n  };\n  // cast: the caller's overloaded type annotation supplies the real signature\n  return dispatch as F;\n}\n","import { dual } from \"./internal/dual.js\";\n\n/**\n * Tagged optional value — a discriminated union over `_tag` where absence\n * (`None`) is an expected outcome, not a failure. Construct with {@link some} /\n * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with\n * {@link match}.\n *\n * @example\n * ```ts\n * function findUser(id: string): Maybe<User> {\n *   return fromNullable(db.users.get(id));\n * }\n * ```\n */\nexport type Maybe<T> = { readonly _tag: \"Some\"; readonly value: T } | { readonly _tag: \"None\" };\n\n/** The `Some` branch of a {@link Maybe} — a present value tagged `\"Some\"`. */\nexport type Some<T> = Extract<Maybe<T>, { _tag: \"Some\" }>;\n\n/** The `None` branch of a {@link Maybe} — expected absence, tagged `\"None\"`. */\nexport type None = Extract<Maybe<never>, { _tag: \"None\" }>;\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 `pure` — alias of {@link some}. One lift name shared across\n * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style\n * code.\n *\n * @example\n * ```ts\n * const m = of(1);   // Maybe<number> — identical to some(1)\n * ```\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 *\n * @example\n * ```ts\n * if (isNone(fromNullable(user))) {\n *   return redirect(\"/login\");   // narrowed to None branch\n * }\n * ```\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(cache.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 const map: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\n  <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, mapImpl);\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 const flatMap: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\n  <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, flatMapImpl);\n\n/**\n * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer\n * {@link flatMap} as the canonical name; reach for `andThen` only when porting\n * neverthrow code or matching its vocabulary.\n *\n * @example\n * ```ts\n * andThen(fromNullable(user), (u) =>\n *   u.active ? some(u) : none(),\n * );\n * ```\n */\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`, use a namespace\n * import (`import * as Maybe from \"@onrails/maybe\"` → `Maybe.match`) to\n * dissolve the collision.\n *\n * @example\n * ```ts\n * const greeting = match(\n *   fromNullable(user),\n *   (u) => `hello ${u.name}`,\n *   () => \"hello guest\",\n * );\n * ```\n */\nexport const match: {\n  <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\n  <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\n} = dual(3, matchImpl);\n\nconst unwrapOrImpl = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n  isSome(maybe) ? maybe.value : defaultValue;\n\nexport const unwrapOr: {\n  <T>(maybe: Maybe<T>, defaultValue: T): T;\n  <T>(defaultValue: T): (maybe: Maybe<T>) => T;\n} = dual(2, unwrapOrImpl);\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 const tap: {\n  <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\n  <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapImpl);\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 const tapNone: {\n  <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\n  <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapNoneImpl);\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`. Mirror of the result package's `show`.\n *\n * @example\n * ```ts\n * show(some(1));   // 'Some(1)'\n * show(none());    // 'None'\n * ```\n */\nexport const show = <T>(maybe: Maybe<T>): string =>\n  isSome(maybe) ? `Some(${printPayload(maybe.value)})` : \"None\";\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { dual } from \"./internal/dual.js\";\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\n/** Construct the {@link NoneError} sentinel. */\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\nconst toResultImpl = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n  isSome(maybe) ? ok(maybe.value) : err(onNone());\n\n/** Lift absence into a domain error. */\nexport const toResult: {\n  <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(maybe: Maybe<T>) => Result<T, E>;\n} = dual(2, toResultImpl);\n\nconst fromResultImpl = <T, E>(result: Result<T, E>): Maybe<T> =>\n  isOk(result) ? some(result.value) : none();\n\n/** Ok values become Some; any Err becomes None (errors are not absence). */\nexport const fromResult: {\n  <T, E>(result: Result<T, E>): Maybe<T>;\n  <T, E>(): (result: Result<T, E>) => Maybe<T>;\n} = dual(1, fromResultImpl);\n\nconst nullableToResultImpl = <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E> =>\n  toResultImpl(fromNullable(value), onNone);\n\n/** Nullable edge → Maybe; explicit None error at the boundary. */\nexport const nullableToResult: {\n  <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(value: T | null | undefined) => Result<T, E>;\n} = dual(2, nullableToResultImpl);\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"]}
+{"version":3,"sources":["../src/internal/dual.ts","../src/maybe.ts","../src/interop.ts"],"names":[],"mappings":";;;;;AAUO,SAAS,IAAA,CAAQ,OAAe,IAAA,EAAwC;AAC7E,EAAA,MAAM,QAAA,GAAW,CAAA,GAAI,IAAA,KACnB,IAAA,CAAK,UAAU,KAAA,GACV,IAAA,CAAsC,GAAG,IAAI,IAC9C,CAAC,IAAA,KAAmB,IAAA,CAAsC,IAAA,EAAM,GAAG,IAAI,CAAA;AAE7E,EAAA,OAAO,QAAA;AACT;;;ACcO,IAAM,OAAO,CAAI,KAAA,MAAwB,EAAE,IAAA,EAAM,QAAQ,KAAA,EAAM,CAAA;AAsB/D,IAAM,IAAA,GAAO,OAA4B,EAAE,IAAA,EAAM,MAAA,EAAO,CAAA;AAYxD,IAAM,MAAA,GAAS,CAAI,KAAA,KAAsC,KAAA,CAAM,IAAA,KAAS,MAAA;AAwBxE,IAAM,YAAA,GAAe,CAAI,KAAA,KAC9B,KAAA,IAAS,OAAO,IAAA,EAAQ,GAAI,KAAK,KAAK,CAAA;;;AClFjC,IAAM,SAAA,GAAY,OAAkB,EAAE,IAAA,EAAM,MAAA,EAAO;AAE1D,IAAM,YAAA,GAAe,CAAO,KAAA,EAAiB,MAAA,KAC3C,MAAA,CAAO,KAAK,CAAA,GAAI,EAAA,CAAS,KAAA,CAAM,KAAK,CAAA,GAAI,GAAA,CAAU,QAAQ,CAAA;AAGrD,IAAM,QAAA,GAGT,IAAA,CAAK,CAAA,EAAG,YAAY;AAExB,IAAM,cAAA,GAAiB,CAAO,MAAA,KAC5B,IAAA,CAAK,MAAM,IAAI,IAAA,CAAK,MAAA,CAAO,KAAK,CAAA,GAAI,IAAA,EAAK;AAGpC,IAAM,UAAA,GAGT,IAAA,CAAK,CAAA,EAAG,cAAc;AAE1B,IAAM,oBAAA,GAAuB,CAAO,KAAA,EAA6B,MAAA,KAC/D,aAAa,YAAA,CAAa,KAAK,GAAG,MAAM,CAAA;AAGnC,IAAM,gBAAA,GAGT,IAAA,CAAK,CAAA,EAAG,oBAAoB;AAGzB,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":["/**\n * Owning module for the dual-form call idiom used across `@onrails/maybe`:\n * a function accepts either data-first (`map(m, fn)`) or curried data-last\n * (`map(fn)(m)`) invocation, dispatching on argument count against a fixed\n * `arity`.\n *\n * This is a deliberate twin of `packages/result/src/internal/dual.ts` — keep\n * the two in sync. No cross-package imports are allowed in this repo, so the\n * helper is vendored independently in each package rather than shared.\n */\nexport function dual<F>(arity: number, body: (...args: never[]) => unknown): F {\n  const dispatch = (...args: unknown[]): unknown =>\n    args.length >= arity\n      ? (body as (...a: unknown[]) => unknown)(...args)\n      : (self: unknown) => (body as (...a: unknown[]) => unknown)(self, ...args);\n  // cast: the caller's overloaded type annotation supplies the real signature\n  return dispatch as F;\n}\n","import { dual } from \"./internal/dual.js\";\n\n/**\n * Tagged optional value — a discriminated union over `_tag` where absence\n * (`None`) is an expected outcome, not a failure. Construct with {@link some} /\n * {@link none}, narrow with {@link isSome} / {@link isNone}, and collapse with\n * {@link match}.\n *\n * @example\n * ```ts\n * function findUser(id: string): Maybe<User> {\n *   return fromNullable(db.users.get(id));\n * }\n * ```\n */\nexport type Maybe<T> = { readonly _tag: \"Some\"; readonly value: T } | { readonly _tag: \"None\" };\n\n/** The `Some` branch of a {@link Maybe} — a present value tagged `\"Some\"`. */\nexport type Some<T> = Extract<Maybe<T>, { _tag: \"Some\" }>;\n\n/** The `None` branch of a {@link Maybe} — expected absence, tagged `\"None\"`. */\nexport type None = Extract<Maybe<never>, { _tag: \"None\" }>;\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 `pure` — alias of {@link some}. One lift name shared across\n * the trio (`of` / `Result.of` / `ResultAsync.of`) for generic and FL-style\n * code.\n *\n * @example\n * ```ts\n * const m = of(1);   // Maybe<number> — identical to some(1)\n * ```\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 *\n * @example\n * ```ts\n * if (isNone(fromNullable(user))) {\n *   return redirect(\"/login\");   // narrowed to None branch\n * }\n * ```\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(cache.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 const map: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;\n  <T, U>(fn: (value: T) => U): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, mapImpl);\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 const flatMap: {\n  <T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;\n  <T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;\n} = dual(2, flatMapImpl);\n\n/**\n * Neverthrow-compat alias of {@link flatMap} — same dual-form shape. Prefer\n * {@link flatMap} as the canonical name; reach for `andThen` only when porting\n * neverthrow code or matching its vocabulary.\n *\n * @example\n * ```ts\n * andThen(fromNullable(user), (u) =>\n *   u.active ? some(u) : none(),\n * );\n * ```\n */\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`, use a namespace\n * import (`import * as Maybe from \"@onrails/maybe\"` → `Maybe.match`) to\n * dissolve the collision.\n *\n * @example\n * ```ts\n * const greeting = match(\n *   fromNullable(user),\n *   (u) => `hello ${u.name}`,\n *   () => \"hello guest\",\n * );\n * ```\n */\nexport const match: {\n  <T, U>(maybe: Maybe<T>, onSome: (value: T) => U, onNone: () => U): U;\n  <T, U>(onSome: (value: T) => U, onNone: () => U): (maybe: Maybe<T>) => U;\n} = dual(3, matchImpl);\n\nconst unwrapOrImpl = <T>(maybe: Maybe<T>, defaultValue: T): T =>\n  isSome(maybe) ? maybe.value : defaultValue;\n\nexport const unwrapOr: {\n  <T>(maybe: Maybe<T>, defaultValue: T): T;\n  <T>(defaultValue: T): (maybe: Maybe<T>) => T;\n} = dual(2, unwrapOrImpl);\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 const tap: {\n  <T>(maybe: Maybe<T>, fn: (value: T) => void): Maybe<T>;\n  <T>(fn: (value: T) => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapImpl);\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 const tapNone: {\n  <T>(maybe: Maybe<T>, fn: () => void): Maybe<T>;\n  <T>(fn: () => void): (maybe: Maybe<T>) => Maybe<T>;\n} = dual(2, tapNoneImpl);\n\nconst printPayload = (payload: unknown): string => {\n  try {\n    return JSON.stringify(payload) ?? String(payload);\n  } catch {\n    // cyclic or non-JSON payload — a debug printer must not throw\n    return String(payload);\n  }\n};\n\n/**\n * Debug printer — renders a maybe as `Some(…)` / `None` for logs. Payloads\n * print as JSON (values are plain data by design); non-JSON payloads fall\n * back to `String(...)`. Mirror of the result package's `show`.\n *\n * @example\n * ```ts\n * show(some(1));   // 'Some(1)'\n * show(none());    // 'None'\n * ```\n */\nexport const show = <T>(maybe: Maybe<T>): string =>\n  isSome(maybe) ? `Some(${printPayload(maybe.value)})` : \"None\";\n","import { err, isOk, ok, type Result } from \"@onrails/result\";\nimport { dual } from \"./internal/dual.js\";\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\n/** Construct the {@link NoneError} sentinel. */\nexport const noneError = (): NoneError => ({ _tag: \"None\" });\n\nconst toResultImpl = <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E> =>\n  isSome(maybe) ? ok<T, E>(maybe.value) : err<T, E>(onNone());\n\n/** Lift absence into a domain error. */\nexport const toResult: {\n  <T, E>(maybe: Maybe<T>, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(maybe: Maybe<T>) => Result<T, E>;\n} = dual(2, toResultImpl);\n\nconst fromResultImpl = <T, E>(result: Result<T, E>): Maybe<T> =>\n  isOk(result) ? some(result.value) : none();\n\n/** Ok values become Some; any Err becomes None (errors are not absence). */\nexport const fromResult: {\n  <T, E>(result: Result<T, E>): Maybe<T>;\n  <T, E>(): (result: Result<T, E>) => Maybe<T>;\n} = dual(1, fromResultImpl);\n\nconst nullableToResultImpl = <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E> =>\n  toResultImpl(fromNullable(value), onNone);\n\n/** Nullable edge → Maybe; explicit None error at the boundary. */\nexport const nullableToResult: {\n  <T, E>(value: T | null | undefined, onNone: () => E): Result<T, E>;\n  <E>(onNone: () => E): <T>(value: T | null | undefined) => Result<T, E>;\n} = dual(2, nullableToResultImpl);\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"]}