ts-data-forge 14.6.4 → 14.7.1

package/src/functional/result/impl/result-safe-try.mts

@@ -1,110 +0,0 @@
-import { hasKey, isRecord } from '../../../guard/index.mjs';
-import { type Err } from '../../../types.mjs';
-import { type Result, type UnknownResult } from '../result.mjs';
-import { type UnwrapErr, type UnwrapOk } from './types.mjs';
-
-/**
- * Runs a generator body in which `yield* Result.safeUnwrap(...)` unwraps `Ok`
- * values and short-circuits on the first `Err`, emulating Rust's `?` operator
- * (early-return error propagation).
- *
- * The body must return a `Result`. If every unwrapped `Result` is `Ok`, the
- * returned value is the body's `Result`; otherwise it is the first `Err`
- * encountered, and the rest of the body never runs — though the generator is
- * closed rather than dropped, so `finally` blocks and `using` disposals
- * pending in the body still run. An exception thrown by the body is not
- * converted to an `Err`: it propagates out of `safeTry` (as a rejected
- * `Promise` for an async body). Use {@link Result.fromThrowable} for that.
- *
- * Passing an async generator (`async function*`) returns a
- * `Promise<Result<...>>` instead, so `await` can be used inside the body.
- * Note that `yield*` inside an `async function*` awaits what it receives, so
- * unwrapping an `Ok` whose value is itself a `Promise` yields the awaited
- * value there while the static type still says `Promise<...>`; keep promises
- * out of the `Ok` side of a `Result` unwrapped in an async body.
- *
- * @example
- *
- * ```ts
- * const parseTwo = (a: string, b: string): Result<number, Error> =>
- *   Result.safeTry(function* () {
- *     const x = yield* Result.safeUnwrap(Num.safeParseInt(a));
- *
- *     const y = yield* Result.safeUnwrap(Num.safeParseInt(b));
- *
- *     return Result.ok(x + y);
- *   });
- *
- * assert.deepStrictEqual(parseTwo('1', '2'), Result.ok(3));
- *
- * assert.isTrue(Result.isErr(parseTwo('1', 'not a number')));
- * ```
- *
- * @template Y The union of `Err` types unwrapped via
- *   {@link Result.safeUnwrap} (`never` if nothing is unwrapped).
- * @template R2 The `Result` type returned by the body.
- * @param body A generator function whose `yield*` expressions delegate to
- *   {@link Result.safeUnwrap} and whose return value is a `Result`.
- * @returns The body's `Result`, or the first `Err` short-circuited out of it
- *   (wrapped in a `Promise` for an async generator body).
- */
-export function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(
-  body: () => Generator<Y, R2>,
-): Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>;
-
-export function safeTry<Y extends Err<unknown>, R2 extends UnknownResult>(
-  body: () => AsyncGenerator<Y, R2>,
-): Promise<Result<UnwrapOk<R2>, UnwrapErr<R2> | UnwrapErr<Y>>>;
-
-export function safeTry(
-  body:
-    | (() => AsyncGenerator<UnknownResult, UnknownResult>)
-    | (() => Generator<UnknownResult, UnknownResult>),
-): Promise<UnknownResult> | UnknownResult {
-  const generator = body();
-
-  // A yielded `Err` and a returned `Result` are both already the final
-  // answer, so the first step's `value` is the result in either case: the
-  // generator is closed rather than resumed after yielding.
-  const step = generator.next();
-
-  if (isSyncStep(step)) {
-    // Dropping a suspended generator would skip the `finally` blocks and
-    // `using` disposals still pending in the body; closing it runs them
-    // before the short-circuited `Err` is handed back. `isSyncGenerator` is
-    // what makes `return()` here synchronous rather than a floating promise.
-    if (step.done !== true && isSyncGenerator(generator, step)) {
-      generator.return(step.value);
-    }
-
-    return step.value;
-  }
-
-  return step.then(async (asyncStep) => {
-    if (asyncStep.done !== true) {
-      await generator.return(asyncStep.value);
-    }
-
-    return asyncStep.value;
-  });
-}
-
-// A sync generator's `next()` returns a plain `{ value, done }` object with
-// own properties, while an async generator's returns a `Promise`, whose
-// `then` lives on the prototype — so an own-key check on `done` separates the
-// two.
-const isSyncStep = (
-  value: unknown,
-): value is IteratorResult<UnknownResult, UnknownResult> =>
-  isRecord(value) && hasKey(value, 'done');
-
-// The generator-side counterpart of `isSyncStep`: a step in the sync form can
-// only have come from a sync generator, so the step is what narrows the
-// generator that produced it — hence the predicate reads its second argument
-// and not its first.
-const isSyncGenerator = (
-  _generator:
-    | AsyncGenerator<UnknownResult, UnknownResult>
-    | Generator<UnknownResult, UnknownResult>,
-  step: unknown,
-): _generator is Generator<UnknownResult, UnknownResult> => isSyncStep(step);

package/src/functional/result/impl/result-safe-unwrap.mts

@@ -1,50 +0,0 @@
-import { type UnknownResult } from '../result.mjs';
-import { isErr } from './result-is-err.mjs';
-import { type NarrowToErr, type UnwrapOk } from './types.mjs';
-
-/**
- * Unwraps a `Result` inside a {@link Result.safeTry} generator body via
- * `yield*`, emulating Rust's `?` operator.
- *
- * If the `Result` is `Ok`, the `yield*` expression evaluates to the contained
- * value and execution continues. If it is `Err`, the error is yielded to
- * {@link Result.safeTry}, which returns it immediately — the rest of the
- * generator body never runs.
- *
- * This generator must only be delegated to (`yield*`) inside a
- * {@link Result.safeTry} body; resuming it after it has yielded an `Err`
- * throws.
- *
- * @example
- *
- * ```ts
- * const result = Result.safeTry(function* () {
- *   const x = yield* Result.safeUnwrap(Result.ok(2));
- *
- *   const y = yield* Result.safeUnwrap(Result.ok(3));
- *
- *   return Result.ok(x + y);
- * });
- *
- * assert.deepStrictEqual(result, Result.ok(5));
- * ```
- *
- * @template R The input `UnknownResult` type.
- * @param result The `Result` to unwrap.
- * @returns A generator that yields the `Err` (if any) and returns the `Ok`
- *   value.
- */
-export function* safeUnwrap<R extends UnknownResult>(
-  result: R,
-): Generator<NarrowToErr<R>, UnwrapOk<R>, unknown> {
-  if (isErr(result)) {
-    yield result;
-
-    throw new Error(
-      '`safeUnwrap()` generator was resumed after yielding an `Err`; it must only be used via `yield*` inside `safeTry()`',
-    );
-  }
-
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  return result.value as UnwrapOk<R>;
-}

package/src/functional/result/impl/result-swap.mts

@@ -1,31 +0,0 @@
-import { type Result, type UnknownResult } from '../result.mjs';
-import { err } from './result-err.mjs';
-import { isOk } from './result-is-ok.mjs';
-import { ok } from './result-ok.mjs';
-import { unwrapOk } from './result-unwrap-ok.mjs';
-import { type UnwrapErr, type UnwrapOk } from './types.mjs';
-
-/**
- * Swaps the success and error values of a `Result`.
- *
- * @example
- *
- * ```ts
- * const okValue = Result.ok('value');
- *
- * const errValue = Result.err('error');
- *
- * assert.deepStrictEqual(Result.swap(okValue), Result.err('value'));
- *
- * assert.deepStrictEqual(Result.swap(errValue), Result.ok('error'));
- * ```
- *
- * @template R The input `UnknownResult` type.
- * @param result The `Result` to swap.
- * @returns A new `Result` with success and error swapped.
- */
-export const swap = <R extends UnknownResult>(
-  result: R,
-): Result<UnwrapErr<R>, UnwrapOk<R>> =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  isOk(result) ? err(unwrapOk(result)) : ok(result.value as UnwrapErr<R>);

package/src/functional/result/impl/result-to-optional.mts

@@ -1,37 +0,0 @@
-import { Optional } from '../../optional/index.mjs';
-import { type UnknownResult } from '../result.mjs';
-import { isOk } from './result-is-ok.mjs';
-import { unwrapOk } from './result-unwrap-ok.mjs';
-import { type UnwrapOk } from './types.mjs';
-
-/**
- * Converts a `Result` to an `Optional`.
- *
- * This conversion is useful when you want to discard error information and
- * only care about whether an operation succeeded. The error information is
- * lost in this conversion, so use it when error details are not needed.
- *
- * If the `Result` is `Ok`, returns `Some` with the value. If the `Result` is
- * `Err`, returns `None`.
- *
- * @example
- *
- * ```ts
- * const okValue = Result.ok(7);
- *
- * const errValue = Result.err('fail');
- *
- * assert.deepStrictEqual(Result.toOptional(okValue), Optional.some(7));
- *
- * assert.deepStrictEqual(Result.toOptional(errValue), Optional.none);
- * ```
- *
- * @template R The input `UnknownResult` type.
- * @param result The `Result` to convert.
- * @returns An `Optional<UnwrapOk<R>>` containing the success value or
- *   representing `None`.
- */
-export const toOptional = <R extends UnknownResult>(
-  result: R,
-): Optional<UnwrapOk<R>> =>
-  isOk(result) ? Optional.some(unwrapOk(result)) : Optional.none;

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

@@ -1,66 +0,0 @@
-import { type UnknownResult } from '../result.mjs';
-import { unwrapErr } from './result-unwrap-err.mjs';
-import { type UnwrapErr } from './types.mjs';
-
-/**
- * Unwraps a `Result`, returning the error value or a default value if it is
- * `Result.Ok`.
- *
- * @example
- *
- * ```ts
- * const okResult = Result.ok('success');
- *
- * const errResult = Result.err('failure');
- *
- * assert.isTrue(Result.unwrapErrOr(okResult, 'default') === 'default');
- *
- * assert.isTrue(Result.unwrapErrOr(errResult, 'default') === 'failure');
- *
- * const unwrapError = Result.unwrapErrOr('fallback error');
- *
- * assert.isTrue(unwrapError(Result.err('boom')) === 'boom');
- *
- * assert.isTrue(unwrapError(Result.ok('no error')) === 'fallback error');
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @template D The type of the default value.
- * @param result The `Result` to unwrap.
- * @param defaultValue The value to return if `result` is `Result.Ok`.
- * @returns The error value if `Result.Err`, otherwise `defaultValue`.
- */
-export function unwrapErrOr<R extends UnknownResult, D>(
-  result: R,
-  defaultValue: D,
-): D | UnwrapErr<R>;
-
-// Curried version
-export function unwrapErrOr<D>(
-  defaultValue: D,
-): <R extends UnknownResult>(result: R) => D | UnwrapErr<R>;
-
-export function unwrapErrOr<R extends UnknownResult, D>(
-  ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]
-): D | UnwrapErr<R> | ((result: R) => D | UnwrapErr<R>) {
-  switch (args.length) {
-    case 2: {
-      // Direct version: first argument is result
-      const [result, defaultValue] = args;
-
-      return unwrapErrOrImpl(result, defaultValue);
-    }
-
-    case 1: {
-      // Curried version
-      const [defaultValue] = args;
-
-      return (result: R) => unwrapErrOrImpl(result, defaultValue);
-    }
-  }
-}
-
-const unwrapErrOrImpl = <R extends UnknownResult, D>(
-  result: R,
-  defaultValue: D,
-): D | UnwrapErr<R> => unwrapErr(result) ?? defaultValue;

package/src/functional/result/impl/result-unwrap-err-throw.mts

@@ -1,56 +0,0 @@
-import { unknownToString } from '../../../others/index.mjs';
-import { match } from '../../match.mjs';
-import { type UnknownResult } from '../result.mjs';
-import { isErr } from './result-is-err.mjs';
-import { type UnwrapErr, type UnwrapOk } from './types.mjs';
-
-/**
- * Unwraps a `Result`, returning the error value. Throws an error if the
- * `Result` is `Result.Ok`.
- *
- * This function is used when you expect a Result to be an error and want to
- * extract the error value. If the Result is unexpectedly Ok, it will throw an
- * error with information about the unexpected success value.
- *
- * @example
- *
- * ```ts
- * const errResult = Result.err(new Error('broken'));
- *
- * const okResult = Result.ok('value');
- *
- * assert.isTrue(Result.unwrapErrThrow(errResult).message === 'broken');
- *
- * assert.throws(() => Result.unwrapErrThrow(okResult), /Expected Err/u);
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @param result The `Result` to unwrap.
- * @param toStr An optional function to convert the success value to a string
- *   for the error message when the Result is unexpectedly Ok. Defaults to
- *   `String`.
- * @returns The error value if `Result.Err`.
- * @throws {Error} Error with message "Expected Err but got Ok: {value}" if
- *   the `Result` is `Result.Ok`.
- */
-export const unwrapErrThrow = <R extends UnknownResult>(
-  result: R,
-  toStr: (v: UnwrapOk<R>) => string = unknownToString,
-): UnwrapErr<R> => {
-  if (isErr(result)) {
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    return result.value as UnwrapErr<R>;
-  }
-
-  const variant = match(result.$$tag, {
-    'ts-data-forge::Result.ok': 'Ok',
-    'ts-data-forge::Result.err': 'Err',
-  });
-
-  throw new Error(
-    `Expected Err but got ${variant}: ${toStr(
-      // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      result.value as UnwrapOk<R>,
-    )}`,
-  );
-};

package/src/functional/result/impl/result-unwrap-err.mts

@@ -1,38 +0,0 @@
-import { type UnknownResult } from '../result.mjs';
-import { isErr } from './result-is-err.mjs';
-import { type UnwrapErr } from './types.mjs';
-
-/**
- * Unwraps a `Result`, returning the error value or `undefined` if it is
- * `Result.Ok`.
- *
- * This provides a safe way to extract error values from Results without
- * throwing exceptions. Useful for error handling patterns where you want to
- * check for specific error conditions.
- *
- * @example
- *
- * ```ts
- * const okResult = Result.ok('data');
- *
- * const errResult = Result.err('problem');
- *
- * // Result.unwrapErr returns undefined for Ok results
- *
- * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
- * assert.isTrue(Result.unwrapErr(okResult) === undefined);
- *
- * // Result.unwrapErr returns the error value for Err results
- *
- * assert.isTrue(Result.unwrapErr(errResult) === 'problem');
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @param result The `Result` to unwrap.
- * @returns The error value if `Result.Err`, otherwise `undefined`.
- */
-export const unwrapErr = <R extends UnknownResult>(
-  result: R,
-): UnwrapErr<R> | undefined =>
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  isErr(result) ? (result.value as UnwrapErr<R>) : undefined;

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

@@ -1,66 +0,0 @@
-import { type UnknownResult } from '../result.mjs';
-import { unwrapOk } from './result-unwrap-ok.mjs';
-import { type UnwrapOk } from './types.mjs';
-
-/**
- * Unwraps a `Result`, returning the success value or a default value if it is
- * `Result.Err`.
- *
- * @example
- *
- * ```ts
- * const okValue = Result.ok(10);
- *
- * const errValue = Result.err('fail');
- *
- * assert.isTrue(Result.unwrapOkOr(okValue, 0) === 10);
- *
- * assert.isTrue(Result.unwrapOkOr(errValue, 0) === 0);
- *
- * const unwrapWithDefault = Result.unwrapOkOr(5);
- *
- * assert.isTrue(unwrapWithDefault(Result.ok(3)) === 3);
- *
- * assert.isTrue(unwrapWithDefault(Result.err('no data')) === 5);
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @template D The type of the default value.
- * @param result The `Result` to unwrap.
- * @param defaultValue The value to return if `result` is `Result.Err`.
- * @returns The success value if `Result.Ok`, otherwise `defaultValue`.
- */
-export function unwrapOkOr<R extends UnknownResult, D>(
-  result: R,
-  defaultValue: D,
-): D | UnwrapOk<R>;
-
-// Curried version
-export function unwrapOkOr<D>(
-  defaultValue: D,
-): <R extends UnknownResult>(result: R) => D | UnwrapOk<R>;
-
-export function unwrapOkOr<R extends UnknownResult, D>(
-  ...args: readonly [result: R, defaultValue: D] | readonly [defaultValue: D]
-): D | UnwrapOk<R> | ((result: R) => D | UnwrapOk<R>) {
-  switch (args.length) {
-    case 2: {
-      // Direct version: first argument is result
-      const [result, defaultValue] = args;
-
-      return unwrapOkOrImpl(result, defaultValue);
-    }
-
-    case 1: {
-      // Curried version
-      const [defaultValue] = args;
-
-      return (result: R) => unwrapOkOrImpl(result, defaultValue);
-    }
-  }
-}
-
-const unwrapOkOrImpl = <R extends UnknownResult, D>(
-  result: R,
-  defaultValue: D,
-): D | UnwrapOk<R> => unwrapOk(result) ?? defaultValue;

package/src/functional/result/impl/result-unwrap-ok.mts

@@ -1,39 +0,0 @@
-import { type Ok } from '../../../types.mjs';
-import { type UnknownResult } from '../result.mjs';
-import { isOk } from './result-is-ok.mjs';
-import { type UnwrapOk } from './types.mjs';
-
-/**
- * Safely unwraps the success value, returning `undefined` for failures.
- *
- * @example
- *
- * ```ts
- * const okResult = Result.ok(42);
- *
- * const errResult = Result.err('oops');
- *
- * // Result.unwrapOk returns the value for Ok results
- *
- * assert.isTrue(Result.unwrapOk(okResult) === 42);
- *
- * // Result.unwrapOk returns undefined for Err results
- *
- * // eslint-disable-next-line @typescript-eslint/no-confusing-void-expression
- * assert.isTrue(Result.unwrapOk(errResult) === undefined);
- * ```
- */
-export function unwrapOk<R extends Ok<unknown>>(result: R): UnwrapOk<R>;
-
-export function unwrapOk<R extends UnknownResult>(
-  result: R,
-): UnwrapOk<R> | undefined;
-
-export function unwrapOk<R extends UnknownResult>(
-  result: R,
-): UnwrapOk<R> | undefined {
-  return isOk(result)
-    ? // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-      (result.value as UnwrapOk<R>)
-    : undefined;
-}

package/src/functional/result/impl/result-unwrap-throw.mts

@@ -1,46 +0,0 @@
-import { unknownToString } from '../../../others/index.mjs';
-import { type UnknownResult } from '../result.mjs';
-import { isErr } from './result-is-err.mjs';
-import { type UnwrapErr, type UnwrapOk } from './types.mjs';
-
-/**
- * Unwraps a `Result`, returning the success value. Throws an error if the
- * `Result` is `Result.Err`.
- *
- * This is useful when you're confident that a Result should contain a success
- * value and want to treat errors as exceptional conditions. The error message
- * will be constructed from the error value using the provided string
- * conversion function.
- *
- * @example
- *
- * ```ts
- * const okResult = Result.ok('data');
- *
- * const errResult = Result.err(new Error('fail'));
- *
- * assert.isTrue(Result.unwrapThrow(okResult) === 'data');
- *
- * assert.throws(() => Result.unwrapThrow(errResult), Error, 'fail');
- * ```
- *
- * @template R The `UnknownResult` type to unwrap.
- * @param result The `Result` to unwrap.
- * @param toStr An optional function to convert the error value to a string
- *   for the error message. Defaults to `String`.
- * @returns The success value if `Result.Ok`.
- * @throws {Error} Error with the stringified error value if the `Result` is
- *   `Result.Err`.
- */
-export const unwrapThrow = <R extends UnknownResult>(
-  result: R,
-  toStr: (e: UnwrapErr<R>) => string = unknownToString,
-): UnwrapOk<R> => {
-  if (isErr(result)) {
-    // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-    throw new Error(toStr(result.value as UnwrapErr<R>));
-  }
-
-  // eslint-disable-next-line total-functions/no-unsafe-type-assertion
-  return result.value as UnwrapOk<R>;
-};

package/src/functional/result/impl/result-zip.mts

@@ -1,42 +0,0 @@
-import { type Result } from '../result.mjs';
-import { isOk } from './result-is-ok.mjs';
-import { ok } from './result-ok.mjs';
-
-/**
- * Combines two `Result` values into a single `Result` containing a tuple. If
- * either `Result` is `Err`, returns the first `Err` encountered.
- *
- * @example
- *
- * ```ts
- * const first = Result.ok('left');
- *
- * const second = Result.ok(1);
- *
- * const expected = ['left', 1] as const;
- *
- * assert.deepStrictEqual(Result.zip(first, second), Result.ok(expected));
- *
- * assert.deepStrictEqual(
- *   Result.zip(first, Result.err('error')),
- *   Result.err('error'),
- * );
- * ```
- *
- * @template S1 The success type of the first `Result`.
- * @template E1 The error type of the first `Result`.
- * @template S2 The success type of the second `Result`.
- * @template E2 The error type of the second `Result`.
- * @param resultA The first `Result`.
- * @param resultB The second `Result`.
- * @returns A `Result` containing a tuple of both values, or the first `Err`.
- */
-export const zip = <S1, E1, S2, E2>(
-  resultA: Result<S1, E1>,
-  resultB: Result<S2, E2>,
-): Result<readonly [S1, S2], E1 | E2> =>
-  isOk(resultA)
-    ? isOk(resultB)
-      ? ok([resultA.value, resultB.value] as const)
-      : resultB
-    : resultA;

package/src/functional/result/impl/tag.mts

@@ -1,8 +0,0 @@
-/** @internal Tag identifying the Ok variant. */
-import { type Err, type Ok } from '../../../types.mjs';
-
-export const OkTypeTagName: Ok<unknown>['$$tag'] = 'ts-data-forge::Result.ok';
-
-/** @internal Tag identifying the Err variant. */
-export const ErrTypeTagName: Err<unknown>['$$tag'] =
-  'ts-data-forge::Result.err';

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

@@ -1,38 +0,0 @@
-import { type Err, type Ok } from '../../../types.mjs';
-import { type UnknownResult } from '../result.mjs';
-
-/**
- * Extracts the success value type `S` from a `Result.Ok<S>`. If the `Result`
- * is `Result.Err<E>`, resolves to `never`.
- *
- * @template R The `UnknownResult` type to unwrap.
- */
-export type UnwrapOk<R extends UnknownResult> =
-  R extends Ok<infer S> ? S : never;
-
-/**
- * Extracts the error value type `E` from a `Result.Err<E>`. If the `Result`
- * is `Result.Ok<S>`, resolves to `never`.
- *
- * @template R The `UnknownResult` type to unwrap.
- */
-export type UnwrapErr<R extends UnknownResult> =
-  R extends Err<infer E> ? E : never;
-
-/**
- * Narrows a `UnknownResult` type to `Result.Ok<S>` if it is an `Ok`. If the
- * `Result` is `Result.Err<E>`, resolves to `never`.
- *
- * @template R The `UnknownResult` type to narrow.
- */
-export type NarrowToOk<R extends UnknownResult> =
-  R extends Ok<unknown> ? R : never;
-
-/**
- * Narrows a `UnknownResult` type to `Result.Err<E>` if it is an `Err`. If the
- * `Result` is `Result.Ok<S>`, resolves to `never`.
- *
- * @template R The `UnknownResult` type to narrow.
- */
-export type NarrowToErr<R extends UnknownResult> =
-  R extends Err<unknown> ? R : never;

package/src/functional/result/index.mts

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

package/src/functional/result/result.mts

@@ -1,19 +0,0 @@
-import { type Err, type Ok } from '../../types.mjs';
-
-/**
- * Represents a value that can either be a success (`Ok`) or an error (`Err`).
- *
- * @template S The type of the success value.
- * @template E The type of the error value.
- */
-export type Result<S, E> = Ok<S> | Err<E>;
-
-/**
- * Base type for any `Result`, used for generic constraints. Represents a
- * `Result` with unknown success and error types.
- */
-export type UnknownResult = Ok<unknown> | Err<unknown>;
-
-export type { Err, Ok } from '../../types.mjs';
-
-export * as Result from './impl/index.mjs';