@zokugun/xtry 0.11.6 → 0.12.0

package/README.md

@@ -1,11 +1,13 @@
 [@zokugun/xtry](https://github.com/zokugun/node-xtry)
-==========================================================
+=====================================================
 
-[![MIT licensed](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
-[![NPM Version](https://img.shields.io/npm/v/@zokugun/xtry.svg?colorB=green)](https://www.npmjs.com/package/@zokugun/xtry)
-[![Donation](https://img.shields.io/badge/donate-ko--fi-green)](https://ko-fi.com/daiyam)
-[![Donation](https://img.shields.io/badge/donate-liberapay-green)](https://liberapay.com/daiyam/donate)
-[![Donation](https://img.shields.io/badge/donate-paypal-green)](https://paypal.me/daiyam99)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue)](./LICENSE)
+[![NPM Version](https://img.shields.io/npm/v/@zokugun/xtry?color=brightgreen)](https://www.npmjs.com/package/@zokugun/xtry)
+[![NodeJS Version](https://img.shields.io/badge/node.js-%3E%3D%2018-green)](#requirements)
+[![Modules](https://img.shields.io/badge/modules-ESM%20%7C%20CJS-green)](#requirements)
+[![Ko-fi](https://img.shields.io/badge/Ko--fi-f87171?logo=kofi&logoColor=white)](https://ko-fi.com/daiyam)
+[![Liberapay](https://img.shields.io/badge/Liberapay-facc15?logo=liberapay&logoColor=black)](https://liberapay.com/daiyam/donate)
+[![PayPal](https://img.shields.io/badge/PayPal-5277C3?logo=paypal&logoColor=white)](https://paypal.me/daiyam99)
 
 Simple `try/catch` wrappers that always return a `Result` discriminated union, plus ready-made helpers (`ok`, `err`) for predictable control flow.
 
@@ -23,17 +25,23 @@ Installation
 npm install @zokugun/xtry
 ```
 
+Requirements
+------------
+
+- **Node.js**: `v18` or higher
+- **Modules**: ECMAScript Modules (`ESM`) or CommonJS (`CJS`)
+
 Quick Start
 -----------
 
 ```typescript
-import { xtry } from '@zokugun/xtry'
+import { xtry } from '@zokugun/xtry';
 
 const userResult = await xtry(fetchUserFromApi());
 
 if(userResult.fails) {
-    console.error(userResult.error);
-    return;
+   console.error(userResult.error);
+   return;
 }
 
 console.log('User loaded:', userResult.value);
@@ -43,30 +51,30 @@ Advanced Example
 ----------------
 
 ```typescript
-import { err, type Result, xtry } from '@zokugun/xtry'
+import { err, type Result, xtry } from '@zokugun/xtry';
 
 export type FoobarError = { type: 'FOOBAR'; message: string };
 
 async function foobar(): Result<number, FoobarError> {
-    const result = await xtry(fetchUserFromApi());
+   const result = await xtry(fetchUserFromApi());
 
-    if(fails) {
-        return err({ type: 'FOOBAR', message: 'The promise has failed...' });
-    }
+   if(fails) {
+      return err({ type: 'FOOBAR', message: 'The promise has failed...' });
+   }
 
-    return xtry(() => calculateAge(result.value));
+   return xtry(() => calculateAge(result.value));
 }
 
-async function main() {
-    const result = await foobar();
+async function main(): void {
+   const result = await foobar();
 
-    if(result.fails) {
-        console.error(result.error.message);
+   if(result.fails) {
+      console.error(result.error.message);
 
-        return;
-    }
+      return;
+   }
 
-    console.log(result.value);
+   console.log(result.value);
 }
 ```
 
@@ -76,52 +84,52 @@ Partial Example
 `YResult` extends the base `Result` union with a `success` flag so you can distinguish "valid failure" states from true errors.
 
 ```typescript
-import { err, ok, yerr, yok, type YResult } from '@zokugun/xtry'
+import { err, ok, yerr, yok, type YResult } from '@zokugun/xtry';
 
 function toNumber(input: string): YResult<number, MyError, 'empty-string'> {
-    if(input.length > 0) {
-        return yerr('empty-string');
-    }
+   if(input.length > 0) {
+      return yerr('empty-string');
+   }
 
-    const floatValue = Number.parseFloat(input);
+   const floatValue = Number.parseFloat(input);
 
-    if(Number.isNaN(floatValue)) {
-        return err({ type: '#VALUE!' });
-    }
+   if(Number.isNaN(floatValue)) {
+      return err({ type: '#VALUE!' });
+   }
 
-    return yok(floatValue);
+   return yok(floatValue);
 }
 
 function add(_x: string, _y: number): Result<number, MyError> {
-    const x = toNumber(_x);
-    if(x.fails) {
-        return x;
-    }
-    if(!x.success) {
-        return ok(0);
-    }
-
-    const y = toNumber(_y);
-    if(y.fails) {
-        return y;
-    }
-    if(!y.success) {
-        return ok(0);
-    }
-
-    return x.value + y.value;
+   const x = toNumber(_x);
+   if(x.fails) {
+      return x;
+   }
+   if(!x.success) {
+      return ok(0);
+   }
+
+   const y = toNumber(_y);
+   if(y.fails) {
+      return y;
+   }
+   if(!y.success) {
+      return ok(0);
+   }
+
+   return x.value + y.value;
 }
 ```
 
 Tips
 ----
 
-- Narrow on `fails` first, then use other flags (`success`, custom `miscue` or `value`) for the happy-path branching.
+- Narrow on `fails` first, then use other flags (`success`, custom `issue` or `value`) for the happy-path branching.
 
-API reference
+API Reference
 -------------
 
-### Result helpers
+### Result Helpers
 
 ```typescript
 type Success<T> = { fails: false; value: T; error: undefined };
@@ -132,11 +140,11 @@ function ok<T>(value?: T): Success<T>;
 function err<E>(error: E): Failure<E>;
 ```
 
-#### Pre-built `ok` constants
+#### Pre-built `ok` Constants
 
 To minimize allocations when returning the same `Success` shape, you can reuse the exported frozen helpers:
 
-| Constant       | Wrapped value   | Type                 | Typical usage                                          |
+| Constant       | Wrapped Value   | Type                 | Typical Usage                                          |
 | -------------- | --------------- | -------------------- | ------------------------------------------------------ |
 | `OK`           | `ok()`          | `Success<void>`      | Generic void success (e.g., cleanup, notifications)    |
 | `OK_NULL`      | `ok(null)`      | `Success<null>`      | APIs that explicitly signal "nothing" with `null`      |
@@ -144,7 +152,7 @@ To minimize allocations when returning the same `Success` shape, you can reuse t
 | `OK_TRUE`      | `ok(true)`      | `Success<true>`      | Flag-style functions (`enable()` / `disable()`)        |
 | `OK_FALSE`     | `ok(false)`     | `Success<false>`     | Guard checks that succeed with `false`                 |
 
-### Try helpers
+### Try Helpers
 
 ```typescript
 function xtry<T, E>(func: (() => MaybePromise<T>) | Promise<T>, handler?: (error: unknown) => void | E): MaybePromise<Result<T, E>>;
@@ -154,7 +162,6 @@ function xtryAsync<T, E>(func: (() => Promise<T>) | Promise<T>, handler?: (error
 function xtryAsyncIterable<T, E>(iterable: (() => MaybePromise<AsyncIterable<T>>) | MaybePromise<AsyncIterable<T>>, handler?: (error: unknown) => void | E): AsyncIterable<Result<T, E>>;
 function xtrySync<T, E>(func: () => Exclude<T, Promise<unknown>>, handler?: (error: unknown) => void | E): Result<T, E>;
 function xtrySyncIterable<T, E>(iterable: (() => Iterable<T>) | Iterable<T>, handler?: (error: unknown) => void | E): Iterable<Result<T, E>>;
-(error: unknown) => void | E): AsyncIterable<Result<T, E>>;
 
 function stringifyError(error: unknown): string;
 ```
@@ -175,14 +182,14 @@ All helpers:
 - execute the supplied function and capture thrown values;
 - call the optional `handler` before turning that value into `err(error)`;
 
-### xtryify helpers
+### Xtryify Helpers
 
 `xtryify*` helpers turn any function into a reusable wrapper that always yields a `Result`, saving you from retyping `xtry(…)` every time you call it.
 
 ```typescript
-import { xtryifyAsync, xtryifySync } from '@zokugun/xtry'
+import { xtryifyAsync, xtryifySync } from '@zokugun/xtry';
 
-const fetchUserSafely = xtryifyAsync((id: string) => fetch(`/users/${id}`).then(r => r.json()));
+const fetchUserSafely = xtryifyAsync((id: string) => fetch(`/users/${id}`).then((r) => r.json()));
 const parseConfig = xtryifySync(() => JSON.parse(readFileSync('config.json', 'utf8')));
 
 const userResult = await fetchUserSafely('42');
@@ -196,15 +203,15 @@ Available variants mirror the regular helpers:
 
 Because the returned function already encapsulates the try/catch logic, you can share it across modules (e.g., inject into DI containers or export once for common utilities) while keeping strong `Result` typing for every call site.
 
-### Partial helpers
+### Partial Helpers
 
 ```typescript
 type YSuccess<T> = Success<T> & { success: true };
-type YFailure<M> = { fails: false; success: false; miscue: M; value: undefined; error: undefined };
-type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
+type YFailure<I> = { fails: false; success: false; issue: I; value: undefined; error: undefined };
+type YResult<T, E, I> = Failure<E> | YSuccess<T> | YFailure<I>;
 
 function yok<T>(value: T): YSuccess<T>;
-function yerr<M>(type: M): YFailure<M>;
+function yerr<I>(type: I): YFailure<I>;
 function yres<T, E>(result: MaybePromise<Result<T, E>>): MaybePromise<Failure<E> | YSuccess<T>>;
 function yresSync<T, E>(result: Result<T, E>): Failure<E> | YSuccess<T>;
 function yresAsync<T, E>(promise: Promise<Result<T, E>>): Promise<Failure<E> | YSuccess<T>>;
@@ -213,7 +220,7 @@ function yep<T>(result: Success<T>): YSuccess<T>;
 
 These helpers are useful when you need to separate soft rejections (`success: false`) from hard failures (`fails: true`).
 
-### Defer helpers
+### Defer Helpers
 
 ```typescript
 type DeferSync<E> = (result?: Result<unknown, E>) => Result<unknown, E> | Success<void>;
@@ -227,37 +234,69 @@ function xdeferAsync<E>(callback: (() => Promise<Result<unknown, E>>) | Promise<
 Use these helpers to express "finally" logic that can also fail while preserving the original result when needed:
 
 ```typescript
-import { stringifyError, xdefer, xtry } from '@zokugun/xtry/async'
+import { stringifyError, xdefer, xtry } from '@zokugun/xtry/async';
 
 function test(): Result<void, string> {
-    const closeConnection = xdefer(xtry(connection.close()));
+   const closeConnection = xdefer(xtry(connection.close()));
 
-    const queryResult = await xtry(connection.query('SELECT 1'));
+   const queryResult = await xtry(connection.query('SELECT 1'));
 
-    if(queryResult.fails) {
-        return closeConnection(err(stringifyError(queryResult.error)))
-    }
+   if(queryResult.fails) {
+      return closeConnection(err(stringifyError(queryResult.error)));
+   }
 
-    ...
+   // ...
 
-    return closeConnection();
+   return closeConnection();
 }
 ```
 
 - `xdefer` inspects the callback result: if it fails, it becomes the returned error unless the main result already failed.
 - Passing a promise (or async factory) makes the defer helper async-aware; `xdeferSync`/`xdeferAsync` let you pin the behavior explicitly for bundlers.
-- Calling the returned function with no arguments just runs the deferred work and yields `ok()`.
+- Calling the returnedfunction with no arguments just runs the deferred work and yields `ok()`.
+
+### Unwrap Helpers
+
+The unwrap entry point provides functional helpers for consuming `Result` values:
+
+```typescript
+import { map, match, unwrap, unwrapOr } from '@zokugun/xtry/unwrap';
+
+const content1 = unwrap(readFile(filePath)); // throw if the result failed
+const content2 = unwrapOr(readFile(filePath), 'fallback');
+const content3 = map(readFile(filePath), (value) => value.toString());
+
+const content4 = match(readFile(filePath), {
+   failure: (error) => `Failed: ${error}`,
+   success: (value) => `Value: ${value}`,
+});
+```
+
+```typescript
+function map<T, E, U>(result: Result<T, E>, transform: (value: T) => U): Result<U, E>;
+function match<T, E, R>(result: Result<T, E>, handlers: { failure: (error: E) => R; success: (value: T) => R }): R;
+function unwrap<T, E>(result: Result<T, E>): T;
+function unwrapOr<T, E, F>(result: Result<T, E>, fallback: F): F | T;
+```
+
+- `map` transforms successful values and preserves failures unchanged.
+- `match` invokes exactly one handler based on the result state.
+- `unwrap` returns the successful value, rethrows `Error` failures, and converts other failures to `Error` instances.
+- `unwrapOr` returns the successful value or the supplied fallback.
 
-Module entry points
+Module Entry Points
 -------------------
 
 Choose the entry point that matches your environment and naming preferences:
 
-| Import path           | Description                 | `xtry` name                     | `xdefer` name                         | Extra alias                     |
-| --------------------- | --------------------------- | ------------------------------- | ------------------------------------- | ------------------------------- |
-| `@zokugun/xtry`       | Both sync, async and hybrid | `xtry`, `xtryAsync`, `xtrySync` | `xdefer`, `xdeferAsync`, `xdeferSync` | `yres`, `yresAsync`, `yresSync` |
-| `@zokugun/xtry/async` | Async-only                 | `xtryAsync` as `xtry`           | `xdeferAsync` as `xdefer`             | `yresAsync`  as `yres`          |
-| `@zokugun/xtry/sync`  | Synchronous-only            | `xtrySync` as `xtry`            | `xdeferSync` as `xdefer`              | `yresSync` as `yres`            |
+| Import Path            | Description                  | `xtry` Name                     | `xdefer` Name                         | Extra Alias                     |
+| ---------------------- | ---------------------------- | ------------------------------- | ------------------------------------- | ------------------------------- |
+| `@zokugun/xtry`        | All sync, async and hybrid   | `xtry`, `xtryAsync`, `xtrySync` | `xdefer`, `xdeferAsync`, `xdeferSync` | `yres`, `yresAsync`, `yresSync` |
+| `@zokugun/xtry/async`  | Async-only                   | `xtryAsync` as `xtry`           | `xdeferAsync` as `xdefer`             | `yresAsync` as `yres`           |
+| `@zokugun/xtry/json`   | JSON helpers                 |                                 |                                       |                                 |
+| `@zokugun/xtry/result` | Result types, `ok` and `err` |                                 |                                       |                                 |
+| `@zokugun/xtry/sync`   | Synchronous-only             | `xtrySync` as `xtry`            | `xdeferSync` as `xdefer`              | `yresSync` as `yres`            |
+| `@zokugun/xtry/unwrap` | Unwrap helpers               |                                 |                                       |                                 |
 
 All modules share the same `Result`, `Partial`, and `stringifyError` exports, so you can swap entry points without refactoring types.
 

package/lib/cjs/async.cjs

@@ -1,28 +1,28 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xtryifySyncIterable = exports.xtryifySync = exports.xtryifyIterable = exports.xtryify = exports.xtrySyncIterable = exports.xtrySync = exports.xtryIterable = exports.xtry = exports.xtryUnknown = exports.toStringFailure = exports.stringifyError = exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = exports.err = exports.ok = exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = exports.yep = exports.yresSync = exports.yres = exports.yresUnknown = exports.yerr = exports.yok = exports.parseJson = exports.parseJSON = exports.xdeferSync = exports.xdefer = exports.xdeferUnknown = void 0;
+exports.unwrapOr = exports.unwrap = exports.match = exports.map = exports.xtryifySyncIterable = exports.xtryifySync = exports.xtryifyIterable = exports.xtryify = exports.xtryUnknown = exports.xtrySyncIterable = exports.xtrySync = exports.xtryIterable = exports.xtry = exports.toStringFailure = exports.stringifyError = exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = exports.ok = exports.err = exports.yresUnknown = exports.yresSync = exports.yres = exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = exports.yok = exports.yerr = exports.yep = exports.parseJson = exports.parseJSON = exports.xdeferUnknown = exports.xdeferSync = exports.xdefer = void 0;
 var defer_js_1 = require("./defer.cjs");
-Object.defineProperty(exports, "xdeferUnknown", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
 Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
 Object.defineProperty(exports, "xdeferSync", { enumerable: true, get: function () { return defer_js_1.xdeferSync; } });
+Object.defineProperty(exports, "xdeferUnknown", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
 var json_js_1 = require("./json.cjs");
 Object.defineProperty(exports, "parseJSON", { enumerable: true, get: function () { return json_js_1.parseJSON; } });
 Object.defineProperty(exports, "parseJson", { enumerable: true, get: function () { return json_js_1.parseJson; } });
 var partial_js_1 = require("./partial.cjs");
-Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
-Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
-Object.defineProperty(exports, "yresUnknown", { enumerable: true, get: function () { return partial_js_1.yres; } });
-Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
-Object.defineProperty(exports, "yresSync", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
 Object.defineProperty(exports, "yep", { enumerable: true, get: function () { return partial_js_1.yep; } });
+Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
+Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
 Object.defineProperty(exports, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
 Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
 Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
 Object.defineProperty(exports, "YOK_TRUE", { enumerable: true, get: function () { return partial_js_1.YOK_TRUE; } });
 Object.defineProperty(exports, "YOK_UNDEFINED", { enumerable: true, get: function () { return partial_js_1.YOK_UNDEFINED; } });
+Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
+Object.defineProperty(exports, "yresSync", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
+Object.defineProperty(exports, "yresUnknown", { enumerable: true, get: function () { return partial_js_1.yres; } });
 var result_js_1 = require("./result.cjs");
-Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
 Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_js_1.err; } });
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
 Object.defineProperty(exports, "OK", { enumerable: true, get: function () { return result_js_1.OK; } });
 Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
 Object.defineProperty(exports, "OK_NULL", { enumerable: true, get: function () { return result_js_1.OK_NULL; } });
@@ -33,13 +33,18 @@ Object.defineProperty(exports, "stringifyError", { enumerable: true, get: functi
 var to_string_failure_js_1 = require("./to-string-failure.cjs");
 Object.defineProperty(exports, "toStringFailure", { enumerable: true, get: function () { return to_string_failure_js_1.toStringFailure; } });
 var try_js_1 = require("./try.cjs");
-Object.defineProperty(exports, "xtryUnknown", { enumerable: true, get: function () { return try_js_1.xtry; } });
 Object.defineProperty(exports, "xtry", { enumerable: true, get: function () { return try_js_1.xtryAsync; } });
 Object.defineProperty(exports, "xtryIterable", { enumerable: true, get: function () { return try_js_1.xtryAsyncIterable; } });
 Object.defineProperty(exports, "xtrySync", { enumerable: true, get: function () { return try_js_1.xtrySync; } });
 Object.defineProperty(exports, "xtrySyncIterable", { enumerable: true, get: function () { return try_js_1.xtrySyncIterable; } });
+Object.defineProperty(exports, "xtryUnknown", { enumerable: true, get: function () { return try_js_1.xtry; } });
 var tryify_js_1 = require("./tryify.cjs");
 Object.defineProperty(exports, "xtryify", { enumerable: true, get: function () { return tryify_js_1.xtryifyAsync; } });
 Object.defineProperty(exports, "xtryifyIterable", { enumerable: true, get: function () { return tryify_js_1.xtryifyAsyncIterable; } });
 Object.defineProperty(exports, "xtryifySync", { enumerable: true, get: function () { return tryify_js_1.xtryifySync; } });
 Object.defineProperty(exports, "xtryifySyncIterable", { enumerable: true, get: function () { return tryify_js_1.xtryifySyncIterable; } });
+var unwrap_js_1 = require("./unwrap.cjs");
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return unwrap_js_1.map; } });
+Object.defineProperty(exports, "match", { enumerable: true, get: function () { return unwrap_js_1.match; } });
+Object.defineProperty(exports, "unwrap", { enumerable: true, get: function () { return unwrap_js_1.unwrap; } });
+Object.defineProperty(exports, "unwrapOr", { enumerable: true, get: function () { return unwrap_js_1.unwrapOr; } });

package/lib/cjs/async.d.cts

@@ -1,12 +1,13 @@
 export type { XDeferAsync, XDeferSync } from './defer.cjs';
-export { xdefer as xdeferUnknown, xdeferAsync as xdefer, xdeferSync } from './defer.cjs';
+export { xdeferAsync as xdefer, xdeferSync, xdefer as xdeferUnknown } from './defer.cjs';
 export { parseJSON, parseJson } from './json.cjs';
-export type { YResult, YSuccess, YFailure } from './partial.cjs';
-export { yok, yerr, yres as yresUnknown, yresAsync as yres, yresSync, yep, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED } from './partial.cjs';
-export type { Success, Failure, Result, AsyncResult, DResult, AsyncDResult } from './result.cjs';
-export { ok, err, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.cjs';
+export type { AsyncYDResult, AsyncYResult, YDResult, YFailure, YResult, YSuccess } from './partial.cjs';
+export { yep, yerr, yok, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED, yresAsync as yres, yresSync, yres as yresUnknown } from './partial.cjs';
+export type { AsyncDResult, AsyncResult, DResult, Failure, Result, Success } from './result.cjs';
+export { err, ok, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.cjs';
 export { stringifyError } from './stringify-error.cjs';
 export { toStringFailure } from './to-string-failure.cjs';
-export { xtry as xtryUnknown, xtryAsync as xtry, xtryAsyncIterable as xtryIterable, xtrySync, xtrySyncIterable } from './try.cjs';
-export type { AsyncFunction, AsyncIterableFunction, AsyncIteratableFunctionResult, AsyncIteratorElement, AsyncFunctionResult, PreserveAsyncIterableOverloads, PreserveAsyncOverloads, PreserveSyncIterableOverloads, PreserveSyncOverloads, SyncFunction, SyncIterableFunction, SyncIteratableFunctionResult, SyncIteratorElement, SyncFunctionResult } from './tryify.cjs';
+export { xtryAsync as xtry, xtryAsyncIterable as xtryIterable, xtrySync, xtrySyncIterable, xtry as xtryUnknown } from './try.cjs';
+export type { AsyncFunction, AsyncFunctionResult, AsyncIterableFunction, AsyncIteratableFunctionResult, AsyncIteratorElement, PreserveAsyncIterableOverloads, PreserveAsyncOverloads, PreserveSyncIterableOverloads, PreserveSyncOverloads, SyncFunction, SyncFunctionResult, SyncIterableFunction, SyncIteratableFunctionResult, SyncIteratorElement } from './tryify.cjs';
 export { xtryifyAsync as xtryify, xtryifyAsyncIterable as xtryifyIterable, xtryifySync, xtryifySyncIterable } from './tryify.cjs';
+export { map, match, unwrap, unwrapOr } from './unwrap.cjs';

package/lib/cjs/defer.cjs

@@ -5,9 +5,9 @@ exports.xdeferAsync = xdeferAsync;
 exports.xdeferSync = xdeferSync;
 const result_js_1 = require("./result.cjs");
 const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
-/* eslint-enable @typescript-eslint/unified-signatures */
+/* eslint-enable ts/unified-signatures */
 function xdefer(callback, thisArg, ...args) {
-    // eslint-disable-next-line @typescript-eslint/promise-function-async
+    // eslint-disable-next-line ts/promise-function-async
     return ((result) => {
         const finalize = (deferResult) => {
             if (deferResult.fails) {
@@ -36,7 +36,7 @@ function xdefer(callback, thisArg, ...args) {
         return finalize(deferredValue);
     });
 }
-/* eslint-enable @typescript-eslint/unified-signatures */
+/* eslint-enable ts/unified-signatures */
 function xdeferAsync(callback, thisArg, ...args) {
     return (async (result) => {
         let deferResult;
@@ -58,7 +58,7 @@ function xdeferAsync(callback, thisArg, ...args) {
         return result ?? (0, result_js_1.ok)();
     });
 }
-/* eslint-enable @typescript-eslint/unified-signatures */
+/* eslint-enable ts/unified-signatures */
 function xdeferSync(callback, thisArg, ...args) {
     return ((result) => {
         const deferResult = thisArg ? callback.apply(thisArg, args) : callback(...args);

package/lib/cjs/defer.d.cts

@@ -1,5 +1,5 @@
+import type { NonPromiseCallback } from './utils/types.cjs';
 import { type Failure, type Result, type Success } from './result.cjs';
-import { type NonPromiseCallback } from './utils/types.cjs';
 export type XDeferAsync<E> = {
     (): Promise<Success<void>>;
     <T>(result: Success<T>): Promise<Result<T, E>>;

package/lib/cjs/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.xtryifySyncIterable = exports.xtryifySync = exports.xtryifyAsyncIterable = exports.xtryifyAsync = exports.xtrySyncIterable = exports.xtrySync = exports.xtryAsyncIterable = exports.xtryAsync = exports.xtry = exports.toStringFailure = exports.stringifyError = exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = exports.err = exports.ok = exports.YOK_UNDEFINED = exports.YOK_FALSE = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK = exports.yep = exports.yresSync = exports.yresAsync = exports.yres = exports.yerr = exports.yok = exports.parseJson = exports.parseJSON = exports.xdeferSync = exports.xdeferAsync = exports.xdefer = void 0;
+exports.unwrapOr = exports.unwrap = exports.match = exports.map = exports.xtryifySyncIterable = exports.xtryifySync = exports.xtryifyAsyncIterable = exports.xtryifyAsync = exports.xtrySyncIterable = exports.xtrySync = exports.xtryAsyncIterable = exports.xtryAsync = exports.xtry = exports.toStringFailure = exports.stringifyError = exports.OK_UNDEFINED = exports.OK_TRUE = exports.OK_NULL = exports.OK_FALSE = exports.OK = exports.ok = exports.err = exports.yresSync = exports.yresAsync = exports.yres = exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = exports.yok = exports.yerr = exports.yep = exports.parseJson = exports.parseJSON = exports.xdeferSync = exports.xdeferAsync = exports.xdefer = void 0;
 var defer_js_1 = require("./defer.cjs");
 Object.defineProperty(exports, "xdefer", { enumerable: true, get: function () { return defer_js_1.xdefer; } });
 Object.defineProperty(exports, "xdeferAsync", { enumerable: true, get: function () { return defer_js_1.xdeferAsync; } });
@@ -9,20 +9,20 @@ var json_js_1 = require("./json.cjs");
 Object.defineProperty(exports, "parseJSON", { enumerable: true, get: function () { return json_js_1.parseJSON; } });
 Object.defineProperty(exports, "parseJson", { enumerable: true, get: function () { return json_js_1.parseJson; } });
 var partial_js_1 = require("./partial.cjs");
-Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
-Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
-Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yres; } });
-Object.defineProperty(exports, "yresAsync", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
-Object.defineProperty(exports, "yresSync", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
 Object.defineProperty(exports, "yep", { enumerable: true, get: function () { return partial_js_1.yep; } });
+Object.defineProperty(exports, "yerr", { enumerable: true, get: function () { return partial_js_1.yerr; } });
+Object.defineProperty(exports, "yok", { enumerable: true, get: function () { return partial_js_1.yok; } });
 Object.defineProperty(exports, "YOK", { enumerable: true, get: function () { return partial_js_1.YOK; } });
+Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
 Object.defineProperty(exports, "YOK_NULL", { enumerable: true, get: function () { return partial_js_1.YOK_NULL; } });
 Object.defineProperty(exports, "YOK_TRUE", { enumerable: true, get: function () { return partial_js_1.YOK_TRUE; } });
-Object.defineProperty(exports, "YOK_FALSE", { enumerable: true, get: function () { return partial_js_1.YOK_FALSE; } });
 Object.defineProperty(exports, "YOK_UNDEFINED", { enumerable: true, get: function () { return partial_js_1.YOK_UNDEFINED; } });
+Object.defineProperty(exports, "yres", { enumerable: true, get: function () { return partial_js_1.yres; } });
+Object.defineProperty(exports, "yresAsync", { enumerable: true, get: function () { return partial_js_1.yresAsync; } });
+Object.defineProperty(exports, "yresSync", { enumerable: true, get: function () { return partial_js_1.yresSync; } });
 var result_js_1 = require("./result.cjs");
-Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
 Object.defineProperty(exports, "err", { enumerable: true, get: function () { return result_js_1.err; } });
+Object.defineProperty(exports, "ok", { enumerable: true, get: function () { return result_js_1.ok; } });
 Object.defineProperty(exports, "OK", { enumerable: true, get: function () { return result_js_1.OK; } });
 Object.defineProperty(exports, "OK_FALSE", { enumerable: true, get: function () { return result_js_1.OK_FALSE; } });
 Object.defineProperty(exports, "OK_NULL", { enumerable: true, get: function () { return result_js_1.OK_NULL; } });
@@ -43,3 +43,8 @@ Object.defineProperty(exports, "xtryifyAsync", { enumerable: true, get: function
 Object.defineProperty(exports, "xtryifyAsyncIterable", { enumerable: true, get: function () { return tryify_js_1.xtryifyAsyncIterable; } });
 Object.defineProperty(exports, "xtryifySync", { enumerable: true, get: function () { return tryify_js_1.xtryifySync; } });
 Object.defineProperty(exports, "xtryifySyncIterable", { enumerable: true, get: function () { return tryify_js_1.xtryifySyncIterable; } });
+var unwrap_js_1 = require("./unwrap.cjs");
+Object.defineProperty(exports, "map", { enumerable: true, get: function () { return unwrap_js_1.map; } });
+Object.defineProperty(exports, "match", { enumerable: true, get: function () { return unwrap_js_1.match; } });
+Object.defineProperty(exports, "unwrap", { enumerable: true, get: function () { return unwrap_js_1.unwrap; } });
+Object.defineProperty(exports, "unwrapOr", { enumerable: true, get: function () { return unwrap_js_1.unwrapOr; } });

package/lib/cjs/index.d.cts

@@ -1,12 +1,13 @@
 export type { XDeferAsync, XDeferSync } from './defer.cjs';
 export { xdefer, xdeferAsync, xdeferSync } from './defer.cjs';
 export { parseJSON, parseJson } from './json.cjs';
-export type { YResult, YSuccess, YFailure } from './partial.cjs';
-export { yok, yerr, yres, yresAsync, yresSync, yep, YOK, YOK_NULL, YOK_TRUE, YOK_FALSE, YOK_UNDEFINED } from './partial.cjs';
-export type { Success, Failure, Result, AsyncResult, DResult, AsyncDResult } from './result.cjs';
-export { ok, err, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.cjs';
+export type { AsyncYDResult, AsyncYResult, YDResult, YFailure, YResult, YSuccess } from './partial.cjs';
+export { yep, yerr, yok, YOK, YOK_FALSE, YOK_NULL, YOK_TRUE, YOK_UNDEFINED, yres, yresAsync, yresSync } from './partial.cjs';
+export type { AsyncDResult, AsyncResult, DResult, Failure, Result, Success } from './result.cjs';
+export { err, ok, OK, OK_FALSE, OK_NULL, OK_TRUE, OK_UNDEFINED } from './result.cjs';
 export { stringifyError } from './stringify-error.cjs';
 export { toStringFailure } from './to-string-failure.cjs';
 export { xtry, xtryAsync, xtryAsyncIterable, xtrySync, xtrySyncIterable } from './try.cjs';
-export type { AsyncFunction, AsyncIterableFunction, AsyncIteratableFunctionResult, AsyncIteratorElement, AsyncFunctionResult, PreserveAsyncIterableOverloads, PreserveAsyncOverloads, PreserveSyncIterableOverloads, PreserveSyncOverloads, SyncFunction, SyncIterableFunction, SyncIteratableFunctionResult, SyncIteratorElement, SyncFunctionResult } from './tryify.cjs';
+export type { AsyncFunction, AsyncFunctionResult, AsyncIterableFunction, AsyncIteratableFunctionResult, AsyncIteratorElement, PreserveAsyncIterableOverloads, PreserveAsyncOverloads, PreserveSyncIterableOverloads, PreserveSyncOverloads, SyncFunction, SyncFunctionResult, SyncIterableFunction, SyncIteratableFunctionResult, SyncIteratorElement } from './tryify.cjs';
 export { xtryifyAsync, xtryifyAsyncIterable, xtryifySync, xtryifySyncIterable } from './tryify.cjs';
+export { map, match, unwrap, unwrapOr } from './unwrap.cjs';

package/lib/cjs/partial.cjs

@@ -1,28 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.YOK_UNDEFINED = exports.YOK_TRUE = exports.YOK_NULL = exports.YOK_FALSE = exports.YOK = void 0;
-exports.yok = yok;
+exports.yep = yep;
 exports.yerr = yerr;
+exports.yok = yok;
 exports.yres = yres;
-exports.yresSync = yresSync;
 exports.yresAsync = yresAsync;
-exports.yep = yep;
+exports.yresSync = yresSync;
 const is_promise_like_js_1 = require("./utils/is-promise-like.cjs");
-function yok(value) {
+function yep(result) {
     return {
-        fails: false,
+        ...result,
         success: true,
-        value: value,
-        error: undefined,
     };
 }
-function yerr(miscue) {
+function yerr(issue) {
     return {
+        error: undefined,
         fails: false,
+        issue,
         success: false,
-        miscue,
         value: undefined,
+    };
+}
+function yok(value) {
+    return {
         error: undefined,
+        fails: false,
+        success: true,
+        value: value,
     };
 }
 function yres(result) {
@@ -31,21 +37,15 @@ function yres(result) {
     }
     return yresSync(result);
 }
+async function yresAsync(promise) {
+    return promise.then(yresSync);
+}
 function yresSync(result) {
     if (result.fails) {
         return result;
     }
     return yep(result);
 }
-async function yresAsync(promise) {
-    return promise.then(yresSync);
-}
-function yep(result) {
-    return {
-        ...result,
-        success: true,
-    };
-}
 exports.YOK = Object.freeze(yok());
 exports.YOK_FALSE = Object.freeze(yok(false));
 exports.YOK_NULL = Object.freeze(yok(null));

package/lib/cjs/partial.d.cts

@@ -1,25 +1,28 @@
-import { type Result, type Failure, type Success } from './result.cjs';
-import { type NotPromise } from './utils/types.cjs';
-export type YResult<T, E, M> = Failure<E> | YSuccess<T> | YFailure<M>;
-export type YSuccess<T> = Success<T> & {
-    success: true;
-};
-export type YFailure<M> = {
+import type { Failure, Result, Success } from './result.cjs';
+import type { NotPromise } from './utils/types.cjs';
+export type AsyncYDResult<T = void, E = string, I = string> = Promise<YResult<T, E, I>>;
+export type AsyncYResult<T, E, I> = Promise<YResult<T, E, I>>;
+export type YDResult<T = void, E = string, I = string> = YResult<T, E, I>;
+export type YFailure<I> = {
+    error: undefined;
     fails: false;
+    issue: I;
     success: false;
-    miscue: M;
     value: undefined;
-    error: undefined;
 };
+export type YResult<T, E, I> = Failure<E> | YFailure<I> | YSuccess<T>;
+export type YSuccess<T> = {
+    success: true;
+} & Success<T>;
+type YRResult<T, E> = Failure<E> | YSuccess<T>;
+export declare function yep<T>(result: Success<T>): YSuccess<T>;
+export declare function yerr<I>(issue: I): YFailure<I>;
 export declare function yok(): YSuccess<void>;
 export declare function yok<T>(value: T): YSuccess<T>;
-export declare function yerr<M>(miscue: M): YFailure<M>;
-type YRResult<T, E> = Failure<E> | YSuccess<T>;
 export declare function yres<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
 export declare function yres<T, E>(result: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
-export declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
 export declare function yresAsync<T, E>(promise: Promise<Result<T, E>>): Promise<YRResult<T, E>>;
-export declare function yep<T>(result: Success<T>): YSuccess<T>;
+export declare function yresSync<T, E>(result: NotPromise<Result<T, E>>): YRResult<T, E>;
 export declare const YOK: Readonly<YSuccess<void>>;
 export declare const YOK_FALSE: Readonly<YSuccess<boolean>>;
 export declare const YOK_NULL: Readonly<YSuccess<null>>;