@onrails/maybe 0.1.0

package/DESIGN.md

@@ -0,0 +1,47 @@
+# @onrails/maybe — design
+
+Expected absence as a tagged union — not failure. Pairs with `@onrails/result` at boundaries.
+
+## Goals
+
+- Same runtime model as `@onrails/result`: `{ _tag }` variants, dual-form module functions, `sideEffects: false`.
+- **Some / None** — not Ok/Err. Do not use Maybe for parse/IO/auth failures.
+- Optional `@onrails/maybe/interop` bridge (`toResult`, `fromResult`) keyed on `@onrails/result`.
+
+## Runtime model
+
+```ts
+type Maybe<T> =
+  | { readonly _tag: "Some"; readonly value: T }
+  | { readonly _tag: "None" };
+```
+
+## API parity with `@onrails/result`
+
+| Result | Maybe |
+|--------|-------|
+| `ok` / `err` | `some` / `none` |
+| `of` | `of` (= `some`) |
+| `map` (dual) | `map` (dual) |
+| `flatMap` (dual) | `flatMap` (dual) |
+| `match` (positional, dual) | `match` (positional, dual) |
+| `matchResult` | `matchMaybe` (collision-free alias) |
+| `unwrapOr` | `unwrapOr` (= `getOrElse`) |
+| — | `compactMap` (`compact` ∘ `map`) |
+| — | `optional` (`flatMap` ∘ `fromNullable`) |
+
+## Type tests
+
+`test/types.spec.ts` uses `ts-expect` (`expectType` + `TypeEqual`) — compile-time assertions, no runtime cost.
+
+## Exports
+
+| Subpath | Purpose |
+|---------|---------|
+| `@onrails/maybe` | Core |
+| `@onrails/maybe/fluent` | Dot-style chains |
+| `@onrails/maybe/interop` | `Result` bridge (peer: `@onrails/result`) |
+
+## Deferred
+
+- Fantasy Land instances.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alan R. Soares
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,41 @@
+# @onrails/maybe
+
+Tagged `Maybe` for **expected absence** — cache miss, optional field, not-ready-yet. Not for failures (use `@onrails/result`).
+
+## Install
+
+```bash
+bun add @onrails/maybe
+```
+
+## Usage
+
+```ts
+import { compactMap, fromNullable, isSome, match, some } from "@onrails/maybe";
+
+const row = fromNullable(db.get(id));
+
+const name = match(
+  row,
+  (r) => r.name,
+  () => "guest",
+);
+```
+
+## Result boundary
+
+```ts
+import { toResult } from "@onrails/maybe/interop";
+
+const user = toResult(fromNullable(row), () => ({ kind: "not_found" as const }));
+```
+
+## Subpaths
+
+| Path | Contents |
+|------|----------|
+| `@onrails/maybe` | Core |
+| `@onrails/maybe/fluent` | `fluent(maybe)` chains |
+| `@onrails/maybe/interop` | `toResult`, `fromResult`, `NoneError` |
+
+See [DESIGN.md](./DESIGN.md).

package/dist/fluent.cjs

@@ -0,0 +1,53 @@
+'use strict';
+
+// src/maybe.ts
+var some = (value) => ({ _tag: "Some", value });
+var none = () => ({ _tag: "None" });
+var isSome = (maybe) => maybe._tag === "Some";
+var mapImpl = (maybe, fn) => isSome(maybe) ? some(fn(maybe.value)) : none();
+function map(...args) {
+  if (args.length === 2) return mapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => mapImpl(maybe, fn);
+}
+var flatMapImpl = (maybe, fn) => isSome(maybe) ? fn(maybe.value) : none();
+function flatMap(...args) {
+  if (args.length === 2) return flatMapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => flatMapImpl(maybe, fn);
+}
+var andThen = flatMap;
+var matchImpl = (maybe, onSome, onNone) => isSome(maybe) ? onSome(maybe.value) : onNone();
+function match(...args) {
+  if (args.length === 3) return matchImpl(args[0], args[1], args[2]);
+  const [onSome, onNone] = args;
+  return (maybe) => matchImpl(maybe, onSome, onNone);
+}
+var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
+var unwrapOr = getOrElse;
+
+// src/fluent.ts
+var fluent = (maybe) => Object.assign(maybe, {
+  map(fn) {
+    return fluent(map(maybe, fn));
+  },
+  flatMap(fn) {
+    return fluent(flatMap(maybe, fn));
+  },
+  andThen(fn) {
+    return fluent(andThen(maybe, fn));
+  },
+  match(onSome, onNone) {
+    return match(maybe, onSome, onNone);
+  },
+  getOrElse(defaultValue) {
+    return getOrElse(maybe, defaultValue);
+  },
+  unwrapOr(defaultValue) {
+    return unwrapOr(maybe, defaultValue);
+  }
+});
+
+exports.fluent = fluent;
+//# sourceMappingURL=fluent.cjs.map
+//# sourceMappingURL=fluent.cjs.map

package/dist/fluent.cjs.map

@@ -0,0 +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","import { andThen, flatMap, getOrElse, type Maybe, map, match, 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  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    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"]}

package/dist/fluent.d.cts

@@ -0,0 +1,13 @@
+import { M as Maybe } from './types-vkiMAo4w.cjs';
+
+type FluentMaybe<T> = Maybe<T> & {
+    map<U>(fn: (value: T) => U): FluentMaybe<U>;
+    flatMap<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;
+    andThen<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;
+    match<U>(onSome: (value: T) => U, onNone: () => U): U;
+    getOrElse(defaultValue: T): T;
+    unwrapOr(defaultValue: T): T;
+};
+declare const fluent: <T>(maybe: Maybe<T>) => FluentMaybe<T>;
+
+export { type FluentMaybe, fluent };

package/dist/fluent.d.ts

@@ -0,0 +1,13 @@
+import { M as Maybe } from './types-vkiMAo4w.js';
+
+type FluentMaybe<T> = Maybe<T> & {
+    map<U>(fn: (value: T) => U): FluentMaybe<U>;
+    flatMap<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;
+    andThen<U>(fn: (value: T) => Maybe<U>): FluentMaybe<U>;
+    match<U>(onSome: (value: T) => U, onNone: () => U): U;
+    getOrElse(defaultValue: T): T;
+    unwrapOr(defaultValue: T): T;
+};
+declare const fluent: <T>(maybe: Maybe<T>) => FluentMaybe<T>;
+
+export { type FluentMaybe, fluent };

package/dist/fluent.js

@@ -0,0 +1,51 @@
+// src/maybe.ts
+var some = (value) => ({ _tag: "Some", value });
+var none = () => ({ _tag: "None" });
+var isSome = (maybe) => maybe._tag === "Some";
+var mapImpl = (maybe, fn) => isSome(maybe) ? some(fn(maybe.value)) : none();
+function map(...args) {
+  if (args.length === 2) return mapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => mapImpl(maybe, fn);
+}
+var flatMapImpl = (maybe, fn) => isSome(maybe) ? fn(maybe.value) : none();
+function flatMap(...args) {
+  if (args.length === 2) return flatMapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => flatMapImpl(maybe, fn);
+}
+var andThen = flatMap;
+var matchImpl = (maybe, onSome, onNone) => isSome(maybe) ? onSome(maybe.value) : onNone();
+function match(...args) {
+  if (args.length === 3) return matchImpl(args[0], args[1], args[2]);
+  const [onSome, onNone] = args;
+  return (maybe) => matchImpl(maybe, onSome, onNone);
+}
+var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
+var unwrapOr = getOrElse;
+
+// src/fluent.ts
+var fluent = (maybe) => Object.assign(maybe, {
+  map(fn) {
+    return fluent(map(maybe, fn));
+  },
+  flatMap(fn) {
+    return fluent(flatMap(maybe, fn));
+  },
+  andThen(fn) {
+    return fluent(andThen(maybe, fn));
+  },
+  match(onSome, onNone) {
+    return match(maybe, onSome, onNone);
+  },
+  getOrElse(defaultValue) {
+    return getOrElse(maybe, defaultValue);
+  },
+  unwrapOr(defaultValue) {
+    return unwrapOr(maybe, defaultValue);
+  }
+});
+
+export { fluent };
+//# sourceMappingURL=fluent.js.map
+//# sourceMappingURL=fluent.js.map

package/dist/fluent.js.map

@@ -0,0 +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","import { andThen, flatMap, getOrElse, type Maybe, map, match, 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  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    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"]}

package/dist/index.cjs

@@ -0,0 +1,68 @@
+'use strict';
+
+// src/maybe.ts
+var some = (value) => ({ _tag: "Some", value });
+var of = some;
+var none = () => ({ _tag: "None" });
+var isSome = (maybe) => maybe._tag === "Some";
+var isNone = (maybe) => maybe._tag === "None";
+var fromNullable = (value) => value == null ? none() : some(value);
+var mapImpl = (maybe, fn) => isSome(maybe) ? some(fn(maybe.value)) : none();
+function map(...args) {
+  if (args.length === 2) return mapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => mapImpl(maybe, fn);
+}
+var flatMapImpl = (maybe, fn) => isSome(maybe) ? fn(maybe.value) : none();
+function flatMap(...args) {
+  if (args.length === 2) return flatMapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => flatMapImpl(maybe, fn);
+}
+var andThen = flatMap;
+var matchImpl = (maybe, onSome, onNone) => isSome(maybe) ? onSome(maybe.value) : onNone();
+function match(...args) {
+  if (args.length === 3) return matchImpl(args[0], args[1], args[2]);
+  const [onSome, onNone] = args;
+  return (maybe) => matchImpl(maybe, onSome, onNone);
+}
+var matchMaybe = match;
+var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
+var unwrapOr = getOrElse;
+var unwrap = (maybe) => {
+  if (isNone(maybe)) {
+    throw new Error("Called unwrap on None");
+  }
+  return maybe.value;
+};
+var compact = (maybes) => {
+  const out = [];
+  for (const m of maybes) {
+    if (isSome(m)) {
+      out.push(m.value);
+    }
+  }
+  return out;
+};
+var compactMap = (items, fn) => compact(items.map(fn));
+var optional = (value, fn) => flatMapImpl(fromNullable(value), fn);
+
+exports.andThen = andThen;
+exports.compact = compact;
+exports.compactMap = compactMap;
+exports.flatMap = flatMap;
+exports.fromNullable = fromNullable;
+exports.getOrElse = getOrElse;
+exports.isNone = isNone;
+exports.isSome = isSome;
+exports.map = map;
+exports.match = match;
+exports.matchMaybe = matchMaybe;
+exports.none = none;
+exports.of = of;
+exports.optional = optional;
+exports.some = some;
+exports.unwrap = unwrap;
+exports.unwrapOr = unwrapOr;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +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/** 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"]}

package/dist/index.d.cts

@@ -0,0 +1,150 @@
+import { M as Maybe, N as None, S as Some } from './types-vkiMAo4w.cjs';
+
+/**
+ * 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 `of` — alias of {@link some}. */
+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`.
+ */
+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(map.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 function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;
+declare function map<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 function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;
+declare function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;
+/** Alias for {@link flatMap} — same dual-form shape. */
+declare const andThen: typeof flatMap;
+/**
+ * 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`, the alias
+ * {@link matchMaybe} is identical.
+ *
+ * @example
+ * ```ts
+ * const greeting = match(
+ *   fromNullable(user),
+ *   (u) => `hello ${u.name}`,
+ *   () => "hello guest",
+ * );
+ * ```
+ */
+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`. */
+declare const matchMaybe: typeof match;
+/**
+ * Returns the `Some` value, or `defaultValue` when the value is `None`.
+ *
+ * @example
+ * ```ts
+ * getOrElse(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.
+ *
+ * @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>;
+
+export { Maybe, None, Some, andThen, compact, compactMap, flatMap, fromNullable, getOrElse, isNone, isSome, map, match, matchMaybe, none, of, optional, some, unwrap, unwrapOr };

package/dist/index.d.ts

@@ -0,0 +1,150 @@
+import { M as Maybe, N as None, S as Some } from './types-vkiMAo4w.js';
+
+/**
+ * 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 `of` — alias of {@link some}. */
+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`.
+ */
+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(map.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 function map<T, U>(maybe: Maybe<T>, fn: (value: T) => U): Maybe<U>;
+declare function map<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 function flatMap<T, U>(maybe: Maybe<T>, fn: (value: T) => Maybe<U>): Maybe<U>;
+declare function flatMap<T, U>(fn: (value: T) => Maybe<U>): (maybe: Maybe<T>) => Maybe<U>;
+/** Alias for {@link flatMap} — same dual-form shape. */
+declare const andThen: typeof flatMap;
+/**
+ * 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`, the alias
+ * {@link matchMaybe} is identical.
+ *
+ * @example
+ * ```ts
+ * const greeting = match(
+ *   fromNullable(user),
+ *   (u) => `hello ${u.name}`,
+ *   () => "hello guest",
+ * );
+ * ```
+ */
+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`. */
+declare const matchMaybe: typeof match;
+/**
+ * Returns the `Some` value, or `defaultValue` when the value is `None`.
+ *
+ * @example
+ * ```ts
+ * getOrElse(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.
+ *
+ * @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>;
+
+export { Maybe, None, Some, andThen, compact, compactMap, flatMap, fromNullable, getOrElse, isNone, isSome, map, match, matchMaybe, none, of, optional, some, unwrap, unwrapOr };

package/dist/index.js

@@ -0,0 +1,50 @@
+// src/maybe.ts
+var some = (value) => ({ _tag: "Some", value });
+var of = some;
+var none = () => ({ _tag: "None" });
+var isSome = (maybe) => maybe._tag === "Some";
+var isNone = (maybe) => maybe._tag === "None";
+var fromNullable = (value) => value == null ? none() : some(value);
+var mapImpl = (maybe, fn) => isSome(maybe) ? some(fn(maybe.value)) : none();
+function map(...args) {
+  if (args.length === 2) return mapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => mapImpl(maybe, fn);
+}
+var flatMapImpl = (maybe, fn) => isSome(maybe) ? fn(maybe.value) : none();
+function flatMap(...args) {
+  if (args.length === 2) return flatMapImpl(args[0], args[1]);
+  const fn = args[0];
+  return (maybe) => flatMapImpl(maybe, fn);
+}
+var andThen = flatMap;
+var matchImpl = (maybe, onSome, onNone) => isSome(maybe) ? onSome(maybe.value) : onNone();
+function match(...args) {
+  if (args.length === 3) return matchImpl(args[0], args[1], args[2]);
+  const [onSome, onNone] = args;
+  return (maybe) => matchImpl(maybe, onSome, onNone);
+}
+var matchMaybe = match;
+var getOrElse = (maybe, defaultValue) => isSome(maybe) ? maybe.value : defaultValue;
+var unwrapOr = getOrElse;
+var unwrap = (maybe) => {
+  if (isNone(maybe)) {
+    throw new Error("Called unwrap on None");
+  }
+  return maybe.value;
+};
+var compact = (maybes) => {
+  const out = [];
+  for (const m of maybes) {
+    if (isSome(m)) {
+      out.push(m.value);
+    }
+  }
+  return out;
+};
+var compactMap = (items, fn) => compact(items.map(fn));
+var optional = (value, fn) => flatMapImpl(fromNullable(value), fn);
+
+export { andThen, compact, compactMap, flatMap, fromNullable, getOrElse, isNone, isSome, map, match, matchMaybe, none, of, optional, some, unwrap, unwrapOr };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +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"]}

package/dist/interop.cjs

@@ -0,0 +1,27 @@
+'use strict';
+
+var result = require('@onrails/result');
+
+// src/interop.ts
+
+// src/maybe.ts
+var some = (value) => ({ _tag: "Some", value });
+var none = () => ({ _tag: "None" });
+var isSome = (maybe) => maybe._tag === "Some";
+var fromNullable = (value) => value == null ? none() : some(value);
+
+// src/interop.ts
+var noneError = () => ({ _tag: "None" });
+var toResult = (maybe, onNone) => isSome(maybe) ? result.ok(maybe.value) : result.err(onNone());
+var fromResult = (result$1) => result.isOk(result$1) ? some(result$1.value) : none();
+var nullableToResult = (value, onNone) => toResult(fromNullable(value), onNone);
+var isNoneError = (result$1) => !result.isOk(result$1) && isNoneErrorValue(result$1.error);
+var isNoneErrorValue = (error) => typeof error === "object" && error !== null && "_tag" in error && error._tag === "None";
+
+exports.fromResult = fromResult;
+exports.isNoneError = isNoneError;
+exports.noneError = noneError;
+exports.nullableToResult = nullableToResult;
+exports.toResult = toResult;
+//# sourceMappingURL=interop.cjs.map
+//# sourceMappingURL=interop.cjs.map

package/dist/interop.cjs.map

@@ -0,0 +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","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.d.cts

@@ -0,0 +1,18 @@
+import { Result } from '@onrails/result';
+import { M as Maybe } from './types-vkiMAo4w.cjs';
+
+/** Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. */
+type NoneError = {
+    readonly _tag: "None";
+};
+declare const noneError: () => NoneError;
+/** Lift absence into a domain error. */
+declare const toResult: <T, E>(maybe: Maybe<T>, onNone: () => E) => Result<T, E>;
+/** Ok values become Some; any Err becomes None (errors are not absence). */
+declare const fromResult: <T, E>(result: Result<T, E>) => Maybe<T>;
+/** Nullable edge → Maybe; explicit None error at the boundary. */
+declare const nullableToResult: <T, E>(value: T | null | undefined, onNone: () => E) => 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 };

package/dist/interop.d.ts

@@ -0,0 +1,18 @@
+import { Result } from '@onrails/result';
+import { M as Maybe } from './types-vkiMAo4w.js';
+
+/** Sentinel error tag — `Maybe<T>` bridges to `Result<T, NoneError>`. */
+type NoneError = {
+    readonly _tag: "None";
+};
+declare const noneError: () => NoneError;
+/** Lift absence into a domain error. */
+declare const toResult: <T, E>(maybe: Maybe<T>, onNone: () => E) => Result<T, E>;
+/** Ok values become Some; any Err becomes None (errors are not absence). */
+declare const fromResult: <T, E>(result: Result<T, E>) => Maybe<T>;
+/** Nullable edge → Maybe; explicit None error at the boundary. */
+declare const nullableToResult: <T, E>(value: T | null | undefined, onNone: () => E) => 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 };

package/dist/interop.js

@@ -0,0 +1,21 @@
+import { ok, err, isOk } from '@onrails/result';
+
+// src/interop.ts
+
+// src/maybe.ts
+var some = (value) => ({ _tag: "Some", value });
+var none = () => ({ _tag: "None" });
+var isSome = (maybe) => maybe._tag === "Some";
+var fromNullable = (value) => value == null ? none() : some(value);
+
+// src/interop.ts
+var noneError = () => ({ _tag: "None" });
+var toResult = (maybe, onNone) => isSome(maybe) ? ok(maybe.value) : err(onNone());
+var fromResult = (result) => isOk(result) ? some(result.value) : none();
+var nullableToResult = (value, onNone) => toResult(fromNullable(value), onNone);
+var isNoneError = (result) => !isOk(result) && isNoneErrorValue(result.error);
+var isNoneErrorValue = (error) => typeof error === "object" && error !== null && "_tag" in error && error._tag === "None";
+
+export { fromResult, isNoneError, noneError, nullableToResult, toResult };
+//# sourceMappingURL=interop.js.map
+//# sourceMappingURL=interop.js.map

package/dist/interop.js.map

@@ -0,0 +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","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/types-vkiMAo4w.d.cts

@@ -0,0 +1,15 @@
+/** Tagged optional value — absence is not failure. */
+type Maybe<T> = {
+    readonly _tag: "Some";
+    readonly value: T;
+} | {
+    readonly _tag: "None";
+};
+type Some<T> = Extract<Maybe<T>, {
+    _tag: "Some";
+}>;
+type None = Extract<Maybe<never>, {
+    _tag: "None";
+}>;
+
+export type { Maybe as M, None as N, Some as S };

package/dist/types-vkiMAo4w.d.ts

@@ -0,0 +1,15 @@
+/** Tagged optional value — absence is not failure. */
+type Maybe<T> = {
+    readonly _tag: "Some";
+    readonly value: T;
+} | {
+    readonly _tag: "None";
+};
+type Some<T> = Extract<Maybe<T>, {
+    _tag: "Some";
+}>;
+type None = Extract<Maybe<never>, {
+    _tag: "None";
+}>;
+
+export type { Maybe as M, None as N, Some as S };

package/package.json

@@ -0,0 +1,82 @@
+{
+  "name": "@onrails/maybe",
+  "version": "0.1.0",
+  "description": "Tagged Maybe for expected absence — pure tagged unions, Result interop, tree-shakeable",
+  "license": "MIT",
+  "author": "Alan R. Soares",
+  "homepage": "https://alanrsoares.github.io/onrails/modules/_onrails_maybe.html",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/alanrsoares/onrails.git",
+    "directory": "packages/maybe"
+  },
+  "bugs": {
+    "url": "https://github.com/alanrsoares/onrails/issues"
+  },
+  "keywords": [
+    "maybe",
+    "optional",
+    "tagged-union",
+    "discriminated-union",
+    "typescript",
+    "bun",
+    "functional"
+  ],
+  "engines": {
+    "node": ">=18",
+    "bun": ">=1.0"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "DESIGN.md",
+    "README.md",
+    "LICENSE"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./fluent": {
+      "types": "./dist/fluent.d.ts",
+      "import": "./dist/fluent.js",
+      "require": "./dist/fluent.cjs"
+    },
+    "./interop": {
+      "types": "./dist/interop.d.ts",
+      "import": "./dist/interop.js",
+      "require": "./dist/interop.cjs"
+    }
+  },
+  "peerDependencies": {
+    "@onrails/result": "0.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@onrails/result": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "bun test",
+    "check": "bun typecheck && bun test",
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@onrails/result": "0.0.0",
+    "ts-expect": "^1.3.0",
+    "tsup": "^8.5.1"
+  }
+}