ts-data-forge 14.5.0 → 14.6.1

package/src/array/impl/array-utils-length-constraint-preservation.test.mts

@@ -32,7 +32,7 @@ describe('map preserves length constraints', () => {
   test('a branded input keeps its constraint', () => {
     const input: MinLengthArray<3, number> = asMinLengthArray(3, [0, 1, 2, 3]);
 
-    const result = map(input, (value) => `#${String(value)}`);
+    const result = map(input, (value) => `#${value.toString()}`);
 
     expectType<typeof result, MinLengthArray<3, string>>('~=');
 
@@ -162,7 +162,7 @@ describe('other length-preserving utilities preserve length constraints', () =>
   test('toUpdated keeps the brand and widens only the element type', () => {
     const input: MinLengthArray<3, number> = asMinLengthArray(3, [0, 1, 2]);
 
-    const result = toUpdated(input, 1, (prev) => `#${String(prev)}`);
+    const result = toUpdated(input, 1, (prev) => `#${prev.toString()}`);
 
     expectType<typeof result, MinLengthArray<3, number | `#${string}`>>('~=');
 

package/src/collections/imap-mapped.mts

@@ -2,7 +2,7 @@
 import { type WidenLiteral } from 'ts-type-forge';
 import { Optional, pipe } from '../functional/index.mjs';
 import { asUint32 } from '../number/index.mjs';
-import { tp } from '../others/index.mjs';
+import { tp, unknownToString } from '../others/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
 
 /**
@@ -1051,7 +1051,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         console.warn(
-          `IMapMapped.delete: key not found: ${String(this.#toKey(key))}`,
+          `IMapMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`,
         );
       }
 
@@ -1103,7 +1103,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
     if (Optional.isNone(curr)) {
       if (this.#showNotFoundMessage) {
         console.warn(
-          `IMapMapped.update: key not found: ${String(this.#toKey(key))}`,
+          `IMapMapped.update: key not found: ${unknownToString(this.#toKey(key))}`,
         );
       }
 
@@ -1160,7 +1160,7 @@ class IMapMappedClass<K, V, KM extends MapSetKeyType>
           if (curr === undefined || !mut_result.has(key)) {
             if (this.#showNotFoundMessage) {
               console.warn(
-                `IMapMapped.withMutations::update: key not found: ${String(key)}`,
+                `IMapMapped.withMutations::update: key not found: ${unknownToString(key)}`,
               );
             }
 

package/src/collections/imap.mts

@@ -753,7 +753,7 @@ class IMapClass<K extends MapSetKeyType, V>
 
   /** @inheritdoc */
   has(key: K | (WidenLiteral<K> & {})): boolean {
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`
     return this.#map.has(key as K);
   }
 

package/src/collections/imap.test.mts

@@ -263,7 +263,7 @@ describe('IMap.has', () => {
 
     assert.isTrue(map.has('1'));
 
-    assert.isTrue(map.has(String(1)));
+    assert.isTrue(map.has((1).toString()));
   });
 });
 

package/src/collections/iset-mapped.mts

@@ -5,6 +5,7 @@ import {
   type WidenLiteral,
 } from 'ts-type-forge';
 import { asUint32 } from '../number/index.mjs';
+import { unknownToString } from '../others/index.mjs';
 import { type MapSetKeyType, type SizeType } from '../types.mjs';
 
 /**
@@ -1270,7 +1271,7 @@ class ISetMappedClass<K, KM extends MapSetKeyType>
     if (!this.has(key)) {
       if (this.#showNotFoundMessage) {
         console.warn(
-          `ISetMapped.delete: key not found: ${String(this.#toKey(key))}`,
+          `ISetMapped.delete: key not found: ${unknownToString(this.#toKey(key))}`,
         );
       }
 

package/src/collections/iset.mts

@@ -753,7 +753,7 @@ class ISetClass<K extends MapSetKeyType> implements ISet<K>, Iterable<K> {
 
   /** @inheritdoc */
   has(key: K | (WidenLiteral<K> & {})): boolean {
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+    // eslint-disable-next-line total-functions/no-unsafe-type-assertion, @typescript-eslint/no-unnecessary-type-assertion -- unnecessary only under the strict standard library; the stock one types `has` as taking exactly `K`
     return this.#set.has(key as K);
   }
 

package/src/functional/async-result/async-result.mts

@@ -0,0 +1,17 @@
+import { type Result } from '../result/index.mjs';
+
+/**
+ * Represents an asynchronous computation that can either succeed (`Ok`) or
+ * fail (`Err`) — a `Promise` that resolves to a `Result<S, E>`.
+ *
+ * Unlike a raw `Promise`, an `AsyncResult` never rejects for expected
+ * failures: errors are carried in the `Err` channel with a concrete type `E`,
+ * so they can be handled with the same combinators as a synchronous
+ * `Result`.
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ */
+export type AsyncResult<S, E> = Promise<Result<S, E>>;
+
+export * as AsyncResult from './impl/index.mjs';

package/src/functional/async-result/impl/async-result-flat-map.mts

@@ -0,0 +1,99 @@
+import { Result, type UnknownResult } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+import {
+  type UnknownAsyncResult,
+  type UnwrapErr,
+  type UnwrapOk,
+} from './types.mjs';
+
+/**
+ * Applies a function that returns an `AsyncResult` or a `Result` to the
+ * success value of an `AsyncResult`. If the input resolves to `Err`, the
+ * original `Err` is passed through and the function is not called. This is
+ * the monadic bind operation for `AsyncResult`.
+ *
+ * @example
+ *
+ * ```ts
+ * const parseNumber = (input: string): Result<number, string> => {
+ *   const num = Number.parseInt(input, 10);
+ *
+ *   return Number.isNaN(num) ? Result.err('not a number') : Result.ok(num);
+ * };
+ *
+ * const input = AsyncResult.fromPromise(
+ *   Promise.resolve('42'),
+ *   () => 'failed',
+ * );
+ *
+ * const parsed = await AsyncResult.flatMap(input, parseNumber);
+ *
+ * assert.deepStrictEqual(parsed, Result.ok(42));
+ * ```
+ *
+ * @template S The type of the success value of the input.
+ * @template E The type of the error value of the input.
+ * @template R2 The `AsyncResult` or `Result` type returned by the function.
+ * @param asyncResult The `AsyncResult` to flat map.
+ * @param flatMapFn The function to apply that returns an `AsyncResult` or a
+ *   `Result`.
+ * @returns The result of applying the function, or the original `Err`.
+ */
+export function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(
+  asyncResult: AsyncResult<S, E>,
+  flatMapFn: (value: S) => R2,
+): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
+
+// Curried version
+//
+// The function's return type is captured as a whole (`R2`) and unwrapped with
+// `UnwrapOk` / `UnwrapErr`, instead of being written as
+// `AsyncResult<S2, E2> | Result<S2, E2>` with separate `S2` / `E2` type
+// parameters. With the union form, inference for `E2` collects a candidate
+// from matching `Ok<S2>` against `Err<E2>` (both have a `value` property), so
+// `E2` ends up as the success type and the call fails to type-check even for
+// a function annotated as returning `Result<S2, E2>`.
+export function flatMap<S, R2 extends UnknownAsyncResult | UnknownResult>(
+  flatMapFn: (value: S) => R2,
+): <E>(
+  asyncResult: AsyncResult<S, E>,
+) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>;
+
+export function flatMap<S, E, R2 extends UnknownAsyncResult | UnknownResult>(
+  ...args:
+    | readonly [asyncResult: AsyncResult<S, E>, flatMapFn: (value: S) => R2]
+    | readonly [flatMapFn: (value: S) => R2]
+):
+  | AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>
+  | ((
+      asyncResult: AsyncResult<S, E>,
+    ) => AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>>) {
+  switch (args.length) {
+    case 2: {
+      // Direct version: first argument is asyncResult
+      const [asyncResult, flatMapFn] = args;
+
+      return flatMapImpl(asyncResult, flatMapFn);
+    }
+
+    case 1: {
+      // Curried version
+      const [flatMapFn] = args;
+
+      return (asyncResult: AsyncResult<S, E>) =>
+        flatMapImpl(asyncResult, flatMapFn);
+    }
+  }
+}
+
+const flatMapImpl = async <S, E, R2 extends UnknownAsyncResult | UnknownResult>(
+  asyncResult: AsyncResult<S, E>,
+  flatMapFn: (value: S) => R2,
+): AsyncResult<UnwrapOk<R2>, E | UnwrapErr<R2>> => {
+  const result = await asyncResult;
+
+  return Result.isErr(result)
+    ? result
+    : // eslint-disable-next-line total-functions/no-unsafe-type-assertion
+      ((await flatMapFn(result.value)) as Result<UnwrapOk<R2>, UnwrapErr<R2>>);
+};

package/src/functional/async-result/impl/async-result-from-promise.mts

@@ -0,0 +1,69 @@
+import { Result } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Converts a `Promise` into an `AsyncResult`. If the input Promise resolves,
+ * the `AsyncResult` resolves to `Ok` with the resolved value. If the input
+ * Promise rejects, the rejection reason is passed through `mapError` and the
+ * `AsyncResult` resolves to `Err` with the mapped error.
+ *
+ * Passing `mapError` is what gives the error channel a concrete type `E`.
+ * Omitting it carries the rejection reason through untouched, leaving the
+ * error channel as `unknown` — the same contract as `Result.fromPromise`.
+ *
+ * @example
+ *
+ * ```ts
+ * const resolved = await AsyncResult.fromPromise(
+ *   Promise.resolve('ok'),
+ *   (error) => `failed: ${String(error)}`,
+ * );
+ *
+ * const rejected = await AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   (error) => (isError(error) ? error.message : 'unknown'),
+ * );
+ *
+ * assert.deepStrictEqual(resolved, Result.ok('ok'));
+ *
+ * assert.deepStrictEqual(rejected, Result.err('boom'));
+ *
+ * // Without `mapError`, the rejection reason is carried as-is.
+ * const untyped = await AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ * );
+ *
+ * assert.isTrue(Result.isErr(untyped));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @param promise The Promise to convert.
+ * @param mapError The function applied to the rejection reason to produce the
+ *   error value. Omit it to carry the rejection reason as `unknown`.
+ * @returns An `AsyncResult<S, E>` that never rejects for the input Promise's
+ *   failure.
+ */
+export function fromPromise<S>(promise: Promise<S>): AsyncResult<S, unknown>;
+
+export function fromPromise<S, E>(
+  promise: Promise<S>,
+  mapError: (error: unknown) => E,
+): AsyncResult<S, E>;
+
+export function fromPromise<S, E>(
+  promise: Promise<S>,
+  mapError?: (error: unknown) => E,
+): AsyncResult<S, E> | AsyncResult<S, unknown> {
+  return mapError === undefined
+    ? fromPromiseImpl(promise, (error: unknown) => error)
+    : fromPromiseImpl(promise, mapError);
+}
+
+const fromPromiseImpl = <S, E>(
+  promise: Promise<S>,
+  mapError: (error: unknown) => E,
+): AsyncResult<S, E> =>
+  promise
+    .then((value) => Result.ok(value))
+    .catch((error: unknown) => Result.err(mapError(error)));

package/src/functional/async-result/impl/async-result-from-throwable.mts

@@ -0,0 +1,78 @@
+import { Result } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Wraps a function returning a `Promise` in an `AsyncResult`. Both a
+ * synchronous `throw` while calling `fn` and an asynchronous rejection of the
+ * returned Promise are caught, passed through `mapError`, and carried as
+ * `Err`.
+ *
+ * Passing `mapError` is what gives the error channel a concrete type `E`.
+ * Omitting it carries the thrown value through untouched, leaving the error
+ * channel as `unknown`.
+ *
+ * @example
+ *
+ * ```ts
+ * const success = await AsyncResult.fromThrowable(
+ *   () => Promise.resolve(2),
+ *   (error) => `failed: ${String(error)}`,
+ * );
+ *
+ * const failure = await AsyncResult.fromThrowable(
+ *   (): Promise<number> => {
+ *     throw new Error('boom');
+ *   },
+ *   (error) => (isError(error) ? error.message : 'unknown'),
+ * );
+ *
+ * assert.deepStrictEqual(success, Result.ok(2));
+ *
+ * assert.deepStrictEqual(failure, Result.err('boom'));
+ *
+ * // Without `mapError`, the thrown value is carried as-is.
+ * const untyped = await AsyncResult.fromThrowable(
+ *   (): Promise<number> => {
+ *     throw new Error('boom');
+ *   },
+ * );
+ *
+ * assert.isTrue(Result.isErr(untyped));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @param fn The function to execute; it may throw synchronously or return a
+ *   rejecting Promise.
+ * @param mapError The function applied to the thrown value or rejection
+ *   reason to produce the error value. Omit it to carry the thrown value as
+ *   `unknown`.
+ * @returns An `AsyncResult<S, E>` containing either the resolved value or the
+ *   mapped error.
+ */
+export function fromThrowable<S>(fn: () => Promise<S>): AsyncResult<S, unknown>;
+
+export function fromThrowable<S, E>(
+  fn: () => Promise<S>,
+  mapError: (error: unknown) => E,
+): AsyncResult<S, E>;
+
+export function fromThrowable<S, E>(
+  fn: () => Promise<S>,
+  mapError?: (error: unknown) => E,
+): AsyncResult<S, E> | AsyncResult<S, unknown> {
+  return mapError === undefined
+    ? fromThrowableImpl(fn, (error: unknown) => error)
+    : fromThrowableImpl(fn, mapError);
+}
+
+const fromThrowableImpl = async <S, E>(
+  fn: () => Promise<S>,
+  mapError: (error: unknown) => E,
+): AsyncResult<S, E> => {
+  try {
+    return Result.ok(await fn());
+  } catch (error) {
+    return Result.err(mapError(error));
+  }
+};

package/src/functional/async-result/impl/async-result-map-err.mts

@@ -0,0 +1,84 @@
+import { Result } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Maps an `AsyncResult<S, E>` to `AsyncResult<S, E2>` by applying a function
+ * to the error value. The mapping function may be synchronous or return a
+ * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
+ * `Ok`, the original `Ok` is passed through and the function is not called.
+ *
+ * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
+ * as-is — it is **not** caught and converted into an `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const errValue = AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   () => 'failure',
+ * );
+ *
+ * const uppercased = await AsyncResult.mapErr(errValue, (error) =>
+ *   error.toUpperCase(),
+ * );
+ *
+ * assert.deepStrictEqual(uppercased, Result.err('FAILURE'));
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value of the input.
+ * @template E2 The type of the error value returned by the mapping function.
+ * @param asyncResult The `AsyncResult` to map.
+ * @param mapFn The function to apply to the error value if present.
+ * @returns A new `AsyncResult<S, E2>`.
+ */
+export function mapErr<S, E, E2>(
+  asyncResult: AsyncResult<S, E>,
+  mapFn: (error: E) => E2 | Promise<E2>,
+): AsyncResult<S, E2>;
+
+// Curried version
+//
+// Unlike `Result.mapErr`, the returned function can simply be generic over
+// `S`: an `AsyncResult` is a `Promise`, not a discriminated union, so there
+// is no literal-narrowing problem that would require the whole-result
+// generic trick used by the synchronous combinators.
+export function mapErr<E, E2>(
+  mapFn: (error: E) => E2 | Promise<E2>,
+): <S>(asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>;
+
+export function mapErr<S, E, E2>(
+  ...args:
+    | readonly [
+        asyncResult: AsyncResult<S, E>,
+        mapFn: (error: E) => E2 | Promise<E2>,
+      ]
+    | readonly [mapFn: (error: E) => E2 | Promise<E2>]
+):
+  | AsyncResult<S, E2>
+  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S, E2>) {
+  switch (args.length) {
+    case 2: {
+      // Direct version: first argument is asyncResult
+      const [asyncResult, mapFn] = args;
+
+      return mapErrImpl(asyncResult, mapFn);
+    }
+
+    case 1: {
+      // Curried version: first argument is mapping function
+      const [mapFn] = args;
+
+      return (asyncResult: AsyncResult<S, E>) => mapErrImpl(asyncResult, mapFn);
+    }
+  }
+}
+
+const mapErrImpl = async <S, E, E2>(
+  asyncResult: AsyncResult<S, E>,
+  mapFn: (error: E) => E2 | Promise<E2>,
+): AsyncResult<S, E2> => {
+  const result = await asyncResult;
+
+  return Result.isOk(result) ? result : Result.err(await mapFn(result.value));
+};

package/src/functional/async-result/impl/async-result-map.mts

@@ -0,0 +1,94 @@
+import { Result } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Maps an `AsyncResult<S, E>` to `AsyncResult<S2, E>` by applying a function
+ * to the success value. The mapping function may be synchronous or return a
+ * `Promise`; both are handled transparently. If the `AsyncResult` resolves to
+ * `Err`, the original `Err` is passed through and the function is not called.
+ *
+ * If `mapFn` throws or returns a rejecting Promise, the rejection propagates
+ * as-is — it is **not** caught and converted into an `Err`. `map` performs no
+ * implicit error conversion; write a fallible step as
+ * `AsyncResult.flatMap` combined with `AsyncResult.fromThrowable` instead, so
+ * that the error type stays explicit.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = AsyncResult.fromPromise(
+ *   Promise.resolve(5),
+ *   () => 'failed',
+ * );
+ *
+ * const doubled = await AsyncResult.map(okValue, (value) => value * 2);
+ *
+ * assert.deepStrictEqual(doubled, Result.ok(10));
+ *
+ * const double = AsyncResult.map((value: number) => value * 2);
+ *
+ * const curried = await double(
+ *   AsyncResult.fromPromise(Promise.resolve(21), () => 'failed'),
+ * );
+ *
+ * assert.deepStrictEqual(curried, Result.ok(42));
+ * ```
+ *
+ * @template S The type of the success value of the input.
+ * @template S2 The type of the success value returned by the mapping
+ *   function.
+ * @template E The type of the error value.
+ * @param asyncResult The `AsyncResult` to map.
+ * @param mapFn The function to apply to the success value if present.
+ * @returns A new `AsyncResult<S2, E>`.
+ */
+export function map<S, S2, E>(
+  asyncResult: AsyncResult<S, E>,
+  mapFn: (value: S) => Promise<S2> | S2,
+): AsyncResult<S2, E>;
+
+// Curried version
+//
+// Unlike `Result.map`, the returned function can simply be generic over `E`:
+// an `AsyncResult` is a `Promise`, not a discriminated union, so there is no
+// literal-narrowing problem that would require the whole-result generic
+// trick used by the synchronous combinators.
+export function map<S, S2>(
+  mapFn: (value: S) => Promise<S2> | S2,
+): <E>(asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>;
+
+export function map<S, S2, E>(
+  ...args:
+    | readonly [
+        asyncResult: AsyncResult<S, E>,
+        mapFn: (value: S) => Promise<S2> | S2,
+      ]
+    | readonly [mapFn: (value: S) => Promise<S2> | S2]
+):
+  | AsyncResult<S2, E>
+  | ((asyncResult: AsyncResult<S, E>) => AsyncResult<S2, E>) {
+  switch (args.length) {
+    case 2: {
+      // Direct version: first argument is asyncResult
+      const [asyncResult, mapFn] = args;
+
+      return mapImpl(asyncResult, mapFn);
+    }
+
+    case 1: {
+      // Curried version
+      const [mapFn] = args;
+
+      return (asyncResult: AsyncResult<S, E>) => mapImpl(asyncResult, mapFn);
+    }
+  }
+}
+
+const mapImpl = async <S, S2, E>(
+  asyncResult: AsyncResult<S, E>,
+  mapFn: (value: S) => Promise<S2> | S2,
+): AsyncResult<S2, E> => {
+  const result = await asyncResult;
+
+  return Result.isErr(result) ? result : Result.ok(await mapFn(result.value));
+};

package/src/functional/async-result/impl/async-result-unwrap-or.mts

@@ -0,0 +1,42 @@
+import { Result } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Unwraps an `AsyncResult`, resolving to the success value or a default value
+ * if it resolves to `Err`.
+ *
+ * @example
+ *
+ * ```ts
+ * const okValue = AsyncResult.fromPromise(
+ *   Promise.resolve(10),
+ *   () => 'failed',
+ * );
+ *
+ * const errValue = AsyncResult.fromPromise(
+ *   Promise.reject(new Error('boom')),
+ *   () => 'failed',
+ * );
+ *
+ * assert.isTrue((await AsyncResult.unwrapOr(okValue, 0)) === 10);
+ *
+ * assert.isTrue((await AsyncResult.unwrapOr(errValue, 0)) === 0);
+ * ```
+ *
+ * @template S The type of the success value.
+ * @template E The type of the error value.
+ * @template D The type of the default value.
+ * @param asyncResult The `AsyncResult` to unwrap.
+ * @param defaultValue The value to resolve to if `asyncResult` resolves to
+ *   `Err`.
+ * @returns A Promise of the success value if `Ok`, otherwise of
+ *   `defaultValue`.
+ */
+export const unwrapOr = async <S, E, D>(
+  asyncResult: AsyncResult<S, E>,
+  defaultValue: D,
+): Promise<D | S> => {
+  const result = await asyncResult;
+
+  return Result.isOk(result) ? result.value : defaultValue;
+};

package/src/functional/async-result/impl/index.mts

@@ -0,0 +1,7 @@
+export * from './async-result-flat-map.mjs';
+export * from './async-result-from-promise.mjs';
+export * from './async-result-from-throwable.mjs';
+export * from './async-result-map-err.mjs';
+export * from './async-result-map.mjs';
+export * from './async-result-unwrap-or.mjs';
+export * from './types.mjs';

package/src/functional/async-result/impl/types.mts

@@ -0,0 +1,51 @@
+import { type Err, type Ok } from '../../../types.mjs';
+import { type UnknownResult } from '../../result/index.mjs';
+import { type AsyncResult } from '../async-result.mjs';
+
+/**
+ * Base type for any `AsyncResult`, used for generic constraints. Represents
+ * an `AsyncResult` with unknown success and error types.
+ */
+export type UnknownAsyncResult = AsyncResult<unknown, unknown>;
+
+/**
+ * Extracts the success value type `S` from a `Result.Ok<S>`, or from an
+ * `AsyncResult` resolving to one. Distributes over unions, so an
+ * `Ok<S> | Err<E>` union resolves to `S`.
+ *
+ * @template R The `Result` or `AsyncResult` type to unwrap.
+ */
+export type UnwrapOk<R extends UnknownAsyncResult | UnknownResult> =
+  UnwrapOkImpl<SyncResultOf<R>>;
+
+/**
+ * Extracts the error value type `E` from a `Result.Err<E>`, or from an
+ * `AsyncResult` resolving to one. Distributes over unions, so an
+ * `Ok<S> | Err<E>` union resolves to `E`.
+ *
+ * @template R The `Result` or `AsyncResult` type to unwrap.
+ */
+export type UnwrapErr<R extends UnknownAsyncResult | UnknownResult> =
+  UnwrapErrImpl<SyncResultOf<R>>;
+
+/**
+ * @template R The `Result` or `AsyncResult` type.
+ * @internal
+ * Resolves an `AsyncResult` to its `Result`, leaving a plain `Result`
+ * unchanged. Distributive.
+ */
+type SyncResultOf<R> = R extends Promise<infer P> ? P : R;
+
+/**
+ * @template R The `Result` type to unwrap.
+ * @internal
+ * Distributive extraction of the `Ok` value type.
+ */
+type UnwrapOkImpl<R> = R extends Ok<infer S> ? S : never;
+
+/**
+ * @template R The `Result` type to unwrap.
+ * @internal
+ * Distributive extraction of the `Err` value type.
+ */
+type UnwrapErrImpl<R> = R extends Err<infer E> ? E : never;

package/src/functional/async-result/index.mts

@@ -0,0 +1 @@
+export * from './async-result.mjs';