resultar 3.0.0 → 3.1.0-beta.1

package/dist/index.d.ts

@@ -26,7 +26,12 @@ type TaggedValue = {
   readonly _tag: string;
 };
 type TaggedErrorValue = Error & TaggedValue;
+type TaggedReasonValue = TaggedValue;
+type TaggedValueWithReason = TaggedValue & {
+  readonly reason: TaggedReasonValue;
+};
 type TagsOf<E> = Extract<E, TaggedValue>["_tag"];
+type TagsWithReasonOf<E> = Extract<E, TaggedValueWithReason>["_tag"];
 type ErrorTagsOf<E> = Extract<E, TaggedErrorValue>["_tag"];
 type ErrorForTag$1<E, Tag extends string> = Extract<E, {
   readonly _tag: Tag;
@@ -35,11 +40,30 @@ type ExcludeTag<E, Tag extends string> = Exclude<E, {
   readonly _tag: Tag;
 }>;
 type UntaggedError$1<E> = Exclude<Extract<E, Error>, TaggedErrorValue>;
+type ReasonsOf<E, ErrorTag extends string> = Extract<ErrorForTag$1<E, ErrorTag>, {
+  readonly reason: TaggedReasonValue;
+}>["reason"];
+type ReasonTagsOf<E, ErrorTag extends string> = ReasonsOf<E, ErrorTag>["_tag"];
+type ReasonForTag<E, ErrorTag extends string, ReasonTag extends string> = Extract<ReasonsOf<E, ErrorTag>, {
+  readonly _tag: ReasonTag;
+}>;
+type ErrorWithRemainingReason<ErrorType, Reason> = [Reason] extends [never] ? never : Omit<ErrorType, "reason"> & {
+  readonly reason: Reason;
+};
+type ExcludeReasonTag<E, ErrorTag extends string, ReasonTag extends string> = Exclude<E, {
+  readonly _tag: ErrorTag;
+}> | ErrorWithRemainingReason<ErrorForTag$1<E, ErrorTag>, Exclude<ReasonsOf<E, ErrorTag>, {
+  readonly _tag: ReasonTag;
+}>>;
 type CatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
+type CatchReasonHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
 type MatchTagHandlerResult<Handlers> = { readonly [Key in keyof Handlers]: Handlers[Key] extends ((...args: infer _Args) => infer R) ? R : never }[keyof Handlers];
 type CatchTagHandlers<E, Handlers, R> = { readonly [Tag in keyof Handlers]: Tag extends TagsOf<E> ? (error: ErrorForTag$1<E, Tag & string>) => R : never };
 type ResultCatchTagHandlers<E, Handlers> = CatchTagHandlers<E, Handlers, Result<unknown, unknown>>;
 type ResultAsyncCatchTagHandlers<E, Handlers> = CatchTagHandlers<E, Handlers, Result<unknown, unknown> | ResultAsync<unknown, unknown>>;
+type CatchReasonHandlers<E, ErrorTag extends string, Handlers, R> = { readonly [ReasonTag in keyof Handlers]: ReasonTag extends ReasonTagsOf<E, ErrorTag> ? (reason: ReasonForTag<E, ErrorTag, ReasonTag & string>, error: ErrorForTag$1<E, ErrorTag>) => R : never };
+type ResultCatchReasonHandlers<E, ErrorTag extends string, Handlers> = CatchReasonHandlers<E, ErrorTag, Handlers, Result<unknown, unknown>>;
+type ResultAsyncCatchReasonHandlers<E, ErrorTag extends string, Handlers> = CatchReasonHandlers<E, ErrorTag, Handlers, Result<unknown, unknown> | ResultAsync<unknown, unknown>>;
 type MatchTagHandlers<E, Handlers> = { readonly [Tag in ErrorTagsOf<E>]: (error: ErrorForTag$1<E, Tag>) => unknown } & ([UntaggedError$1<E>] extends [never] ? {
   readonly Error?: (error: Error) => unknown;
 } : {
@@ -52,6 +76,11 @@ type ResultFinalizer<T, E> = (value: T | undefined, error: E | undefined) => voi
 type MatchOkHandler<T, A> = (value: T) => A;
 type MatchErrorHandler<E, B> = (error: E) => B;
 type ResultCandidate = () => Result<unknown, unknown>;
+type ResultRecord = Readonly<Record<string, Result<unknown, unknown>>>;
+type CombineResultsRecord<T extends ResultRecord> = Result<{ readonly [Key in keyof T]: InferOkTypes<T[Key]> }, InferErrTypes<T[keyof T]>>;
+type CombineResultsRecordWithAllErrors<T extends ResultRecord> = Result<{ readonly [Key in keyof T]: InferOkTypes<T[Key]> }, InferErrTypes<T[keyof T]>[]>;
+type CombineResultsIterable<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>>;
+type CombineResultsIterableWithAllErrors<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>[]>;
 type ResultLoopCollected<R extends Result<unknown, unknown>> = Result<readonly InferOkTypes<R>[], InferErrTypes<R>>;
 type ResultLoopDiscarded<R extends Result<unknown, unknown>> = Result<void, InferErrTypes<R>>;
 type ResultIterated<State, R extends Result<State, unknown>> = Result<State, InferErrTypes<R>>;
@@ -177,6 +206,9 @@ interface ResultOperations<T, E> {
   orElse<R extends Result<unknown, unknown>>(f: (e: E) => R): Result<InferOkTypes<R> | T, InferErrTypes<R>>;
   catchTag<const Tag extends TagsOf<E>, R extends Result<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R): Result<T | InferOkTypes<R>, ExcludeTag<E, Tag> | InferErrTypes<R>>;
   catchTags<const Handlers extends object>(handlers: Handlers & ResultCatchTagHandlers<E, Handlers>): Result<T | InferOkTypes<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | InferErrTypes<CatchTagHandlerResult<Handlers>>>;
+  catchReason<const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>, R extends Result<unknown, unknown>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => R): Result<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>>;
+  catchReasons<const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(errorTag: ErrorTag, handlers: Handlers & ResultCatchReasonHandlers<E, ErrorTag, Handlers>): Result<T | InferOkTypes<CatchReasonHandlerResult<Handlers>>, ExcludeReasonTag<E, ErrorTag, keyof Handlers & string> | InferErrTypes<CatchReasonHandlerResult<Handlers>>>;
+  unwrapReason<const ErrorTag extends TagsWithReasonOf<E>>(errorTag: ErrorTag): Result<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>>;
   asyncAndThen<X, Y>(f: (t: T) => ResultAsync<X, Y>): ResultAsync<X, E | Y>;
   asyncMap<X>(f: (t: T) => Promise<X>): ResultAsync<X, E>;
   match<A, B = A>(handlers: MatchHandlers$1<T, E, A, B>): A | B;
@@ -229,8 +261,12 @@ interface ResultStatic {
   err<T = never>(this: void, err: void): ErrResult<T, void>;
   combine<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResults<T>;
   combine<T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResults<T>;
+  combine<T extends ResultRecord>(this: void, resultRecord: T): CombineResultsRecord<T>;
+  combine<R extends Result<unknown, unknown>>(this: void, results: Iterable<R>): CombineResultsIterable<R>;
   combineWithAllErrors<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
   combineWithAllErrors<T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
+  combineWithAllErrors<T extends ResultRecord>(this: void, resultRecord: T): CombineResultsRecordWithAllErrors<T>;
+  combineWithAllErrors<R extends Result<unknown, unknown>>(this: void, results: Iterable<R>): CombineResultsIterableWithAllErrors<R>;
   validateAll<T extends readonly [Result<unknown, unknown>, ...Result<unknown, unknown>[]]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
   validateAll<T extends readonly Result<unknown, unknown>[]>(this: void, resultList: T): CombineResultsWithAllErrorsArray<T>;
   validateAll<Item, R extends Result<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R): ResultValidatedAll<R>;
@@ -341,16 +377,83 @@ type TraverseWithAllErrors<T, Depth extends number = 5> = Traverse<T, Depth> ext
 type CombineResults<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? Traverse<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number]>;
 type CombineResultsWithAllErrorsArray<T extends readonly Result<unknown, unknown>[]> = IsLiteralArray<T> extends 1 ? TraverseWithAllErrors<T> : Result<ExtractOkTypes<T>, ExtractErrTypes<T>[number][]>;
 //#endregion
+//#region src/abort-error.d.ts
+declare class AbortError extends Error {
+  constructor(message?: string, options?: ErrorOptions);
+}
+declare const isAbortError: (value: unknown) => value is AbortError;
+//#endregion
 //#region src/result-async.d.ts
 type ResultAsyncFinalizer<T, E> = (value: T | undefined, error: E | undefined) => void | Promise<void>;
 interface TryResultAsyncOptions<T, E = unknown> {
   readonly try: () => Promise<T>;
   readonly catch?: (e: unknown) => E;
 }
+interface ResultAsyncAbortSignal {
+  readonly aborted: boolean;
+  readonly reason?: unknown;
+  addEventListener(type: "abort", listener: () => void, options?: {
+    readonly once?: boolean;
+  }): void;
+  removeEventListener(type: "abort", listener: () => void): void;
+}
+type ResultAsyncConcurrency = number | "unbounded";
 type HandlerOk<R> = InferOkTypes<R> | InferAsyncOkTypes<R>;
 type HandlerErr<R> = InferErrTypes<R> | InferAsyncErrTypes<R>;
 type IterableElement<T> = T extends Iterable<infer Element> ? Element : never;
 type ResultAsyncCandidate = () => ResultAsync<unknown, unknown>;
+type ResultAsyncRecord = Readonly<Record<string, ResultAsync<unknown, unknown>>>;
+type CombineResultAsyncsRecord<T extends ResultAsyncRecord> = ResultAsync<{ readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]> }, InferAsyncErrTypes<T[keyof T]>>;
+type CombineResultAsyncsRecordWithAllErrors<T extends ResultAsyncRecord> = ResultAsync<{ readonly [Key in keyof T]: InferAsyncOkTypes<T[Key]> }, InferAsyncErrTypes<T[keyof T]>[]>;
+type CombineResultAsyncsIterable<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>;
+type CombineResultAsyncsIterableWithAllErrors<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>[]>;
+type ResultAsyncRaceTask<T, E> = (signal: ResultAsyncAbortSignal) => ResultAsync<T, E>;
+type ResultAsyncRaceTaskOk<Task> = Task extends ResultAsyncRaceTask<infer T, unknown> ? T : never;
+type ResultAsyncRaceTaskErr<Task> = Task extends ResultAsyncRaceTask<unknown, infer E> ? E : never;
+type ResultAsyncRaceTasksOk<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> = ResultAsyncRaceTaskOk<Tasks[number]>;
+type ResultAsyncRaceTasksErr<Tasks extends readonly ResultAsyncRaceTask<unknown, unknown>[]> = ResultAsyncRaceTaskErr<Tasks[number]>;
+interface ResultAsyncRaceHandle<T, E> {
+  readonly signal: ResultAsyncAbortSignal;
+  abort(reason?: unknown): void;
+  wait(): ResultAsync<T, E>;
+}
+interface ResultAsyncTimeoutOptions<E> {
+  readonly onTimeout: () => E;
+  readonly timeoutMs: number;
+}
+interface ResultAsyncRetryContext {
+  readonly attempt: number;
+  readonly nextAttempt: number;
+  readonly retriesRemaining: number;
+}
+type ResultAsyncRetryTask<T, E> = (attempt: number, signal: ResultAsyncAbortSignal) => ResultAsync<T, E>;
+type ResultAsyncRetryTaskOk<Task> = Task extends ResultAsyncRetryTask<infer T, unknown> ? T : never;
+type ResultAsyncRetryTaskErr<Task> = Task extends ResultAsyncRetryTask<unknown, infer E> ? E : never;
+type ResultAsyncRetryDelay = number | ((context: ResultAsyncRetryContext) => number);
+interface ResultAsyncRetryOptions<E> {
+  readonly delayMs?: ResultAsyncRetryDelay;
+  readonly onRetry?: (error: E, context: ResultAsyncRetryContext) => void | Promise<void>;
+  readonly signal?: ResultAsyncAbortSignal;
+  readonly times: number;
+  readonly while?: (error: E, context: ResultAsyncRetryContext) => boolean | Promise<boolean>;
+}
+interface ResultAsyncRetryOrElseOptions<E, F, U> extends ResultAsyncRetryOptions<E> {
+  readonly orElse: (error: E, context: ResultAsyncRetryContext) => Result<U, F> | ResultAsync<U, F>;
+}
+type ResultAsyncResourceAcquire<Resource, E> = (signal: ResultAsyncAbortSignal) => ResultAsync<Resource, E>;
+type ResultAsyncResourceEffect<T, E> = Result<T, E> | ResultAsync<T, E>;
+type ResultAsyncResourceUse<Resource, T, E> = (resource: Resource, signal: ResultAsyncAbortSignal) => ResultAsyncResourceEffect<T, E>;
+interface ResultAsyncResourceReleaseContext {
+  readonly result: Result<unknown, unknown> | undefined;
+  readonly signal: ResultAsyncAbortSignal;
+}
+type ResultAsyncResourceRelease<Resource> = (resource: Resource, context: ResultAsyncResourceReleaseContext) => ResultAsyncResourceEffect<unknown, unknown> | Promise<void> | void;
+interface ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError> {
+  readonly acquire: ResultAsyncResourceAcquire<Resource, AcquireError>;
+  readonly release: ResultAsyncResourceRelease<Resource>;
+  readonly signal?: ResultAsyncAbortSignal;
+  readonly use: ResultAsyncResourceUse<Resource, T, UseError>;
+}
 type FirstSuccessOfAsync<Candidates extends Iterable<ResultAsyncCandidate>> = ResultAsync<InferAsyncOkTypes<ReturnType<IterableElement<Candidates>>>, InferAsyncErrTypes<ReturnType<IterableElement<Candidates>>>>;
 type ResultAsyncLoopCollected<R extends ResultAsync<unknown, unknown>> = ResultAsync<readonly InferAsyncOkTypes<R>[], InferAsyncErrTypes<R>>;
 type ResultAsyncLoopDiscarded<R extends ResultAsync<unknown, unknown>> = ResultAsync<void, InferAsyncErrTypes<R>>;
@@ -399,11 +502,16 @@ interface ResultAsyncIterateBooleanOptions<State, R extends ResultAsync<State, u
   readonly while: (state: State) => boolean;
 }
 interface ResultAsyncForEachOptions {
+  readonly concurrency?: ResultAsyncConcurrency;
   readonly discard?: false;
 }
 interface ResultAsyncForEachDiscardOptions {
+  readonly concurrency?: ResultAsyncConcurrency;
   readonly discard: true;
 }
+interface ResultAsyncValidateAllOptions {
+  readonly concurrency?: ResultAsyncConcurrency;
+}
 interface ResultAsyncIfOptions<OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional> {
   readonly onFalse: () => OnFalse;
   readonly onTrue: () => OnTrue;
@@ -511,12 +619,27 @@ declare class ResultAsync<T, E> extends Pipeable implements PromiseLike<Result<T
   static fromPromise<T, E>(this: void, promise: PromiseLike<T>, errorFn: (e: unknown) => E): ResultAsync<T, E>;
   static combine<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultAsyncs<T>;
   static combine<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultAsyncs<T>;
+  static combine<T extends ResultAsyncRecord>(this: void, asyncResultRecord: T): CombineResultAsyncsRecord<T>;
+  static combine<R extends ResultAsync<unknown, unknown>>(this: void, asyncResults: Iterable<R>): CombineResultAsyncsIterable<R>;
   static combineWithAllErrors<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
   static combineWithAllErrors<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
+  static combineWithAllErrors<T extends ResultAsyncRecord>(this: void, asyncResultRecord: T): CombineResultAsyncsRecordWithAllErrors<T>;
+  static combineWithAllErrors<R extends ResultAsync<unknown, unknown>>(this: void, asyncResults: Iterable<R>): CombineResultAsyncsIterableWithAllErrors<R>;
   static validateAll<T extends readonly [ResultAsync<unknown, unknown>, ...ResultAsync<unknown, unknown>[]]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
   static validateAll<T extends readonly ResultAsync<unknown, unknown>[]>(this: void, asyncResultList: T): CombineResultsWithAllErrorsArrayAsync<T>;
-  static validateAll<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R): ResultAsyncValidatedAll<R>;
+  static validateAll<Item, R extends ResultAsync<unknown, unknown>>(this: void, items: Iterable<Item>, f: (value: Item, index: number) => R, options?: ResultAsyncValidateAllOptions): ResultAsyncValidatedAll<R>;
   static zip<Left extends ResultAsync<unknown, unknown>, Right extends ResultAsync<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsyncZipped<Left, Right>;
+  static retry<Task extends ResultAsyncRetryTask<unknown, unknown>>(this: void, task: Task, options: ResultAsyncRetryOptions<ResultAsyncRetryTaskErr<Task>>): ResultAsync<ResultAsyncRetryTaskOk<Task>, ResultAsyncRetryTaskErr<Task> | AbortError>;
+  static retryOrElse<Task extends ResultAsyncRetryTask<unknown, unknown>, U, F>(this: void, task: Task, options: ResultAsyncRetryOrElseOptions<ResultAsyncRetryTaskErr<Task>, F, U>): ResultAsync<ResultAsyncRetryTaskOk<Task> | U, F | AbortError>;
+  static withResource<Resource, AcquireError, T, UseError>(this: void, options: ResultAsyncWithResourceOptions<Resource, AcquireError, T, UseError>): ResultAsync<T, AcquireError | UseError | AbortError>;
+  static race<Left extends ResultAsyncRaceTask<unknown, unknown>, Right extends ResultAsyncRaceTask<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsync<ResultAsyncRaceTaskOk<Left> | ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Left> | ResultAsyncRaceTaskErr<Right>>;
+  static raceAll<Tasks extends readonly [ResultAsyncRaceTask<unknown, unknown>, ...ResultAsyncRaceTask<unknown, unknown>[]]>(this: void, tasks: Tasks): ResultAsync<ResultAsyncRaceTasksOk<Tasks>, ResultAsyncRaceTasksErr<Tasks>>;
+  static raceFirst<Left extends ResultAsyncRaceTask<unknown, unknown>, Right extends ResultAsyncRaceTask<unknown, unknown>>(this: void, left: Left, right: Right): ResultAsync<ResultAsyncRaceTaskOk<Left> | ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Left> | ResultAsyncRaceTaskErr<Right>>;
+  static raceWith<Left extends ResultAsyncRaceTask<unknown, unknown>, Right extends ResultAsyncRaceTask<unknown, unknown>, OnLeftDone extends ResultAsyncConditional, OnRightDone extends ResultAsyncConditional>(this: void, left: Left, right: Right, handlers: {
+    readonly onLeftDone: (result: Result<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>, right: ResultAsyncRaceHandle<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>) => OnLeftDone;
+    readonly onRightDone: (result: Result<ResultAsyncRaceTaskOk<Right>, ResultAsyncRaceTaskErr<Right>>, left: ResultAsyncRaceHandle<ResultAsyncRaceTaskOk<Left>, ResultAsyncRaceTaskErr<Left>>) => OnRightDone;
+  }): ResultAsync<HandlerOk<OnLeftDone> | HandlerOk<OnRightDone>, HandlerErr<OnLeftDone> | HandlerErr<OnRightDone>>;
+  static timeout<Task extends ResultAsyncRaceTask<unknown, unknown>, TimeoutError>(this: void, task: Task, options: ResultAsyncTimeoutOptions<TimeoutError>): ResultAsync<ResultAsyncRaceTaskOk<Task>, ResultAsyncRaceTaskErr<Task> | TimeoutError>;
   static firstSuccessOf<Candidates extends Iterable<ResultAsyncCandidate>>(this: void, candidates: Candidates): FirstSuccessOfAsync<Candidates>;
   static if<OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(this: void, condition: ResultAsyncBooleanCondition, options: ResultAsyncIfOptions<OnTrue, OnFalse>): ResultAsyncIf<never, OnTrue, OnFalse>;
   static if<Condition extends ResultAsyncConditionResult, OnTrue extends ResultAsyncConditional, OnFalse extends ResultAsyncConditional>(this: void, condition: Condition, options: ResultAsyncIfOptions<OnTrue, OnFalse>): ResultAsyncIf<HandlerErr<Condition>, OnTrue, OnFalse>;
@@ -564,6 +687,11 @@ declare class ResultAsync<T, E> extends Pipeable implements PromiseLike<Result<T
   catchTag<const Tag extends TagsOf<E>, R extends ResultAsync<unknown, unknown>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => R): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeTag<E, Tag> | InferAsyncErrTypes<R>>;
   catchTag<U, F, const Tag extends TagsOf<E>>(tag: Tag, f: (error: ErrorForTag$1<E, Tag>) => Result<U, F> | ResultAsync<U, F>): ResultAsync<T | U, ExcludeTag<E, Tag> | F>;
   catchTags<const Handlers extends object>(handlers: Handlers & ResultAsyncCatchTagHandlers<E, Handlers>): ResultAsync<T | HandlerOk<CatchTagHandlerResult<Handlers>>, ExcludeTag<E, keyof Handlers & string> | HandlerErr<CatchTagHandlerResult<Handlers>>>;
+  catchReason<const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>, R extends Result<unknown, unknown>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => R): ResultAsync<T | InferOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferErrTypes<R>>;
+  catchReason<const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>, R extends ResultAsync<unknown, unknown>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => R): ResultAsync<T | InferAsyncOkTypes<R>, ExcludeReasonTag<E, ErrorTag, ReasonTag> | InferAsyncErrTypes<R>>;
+  catchReason<U, F, const ErrorTag extends TagsWithReasonOf<E>, const ReasonTag extends ReasonTagsOf<E, ErrorTag>>(errorTag: ErrorTag, reasonTag: ReasonTag, f: (reason: ReasonForTag<E, ErrorTag, ReasonTag>, error: ErrorForTag$1<E, ErrorTag>) => Result<U, F> | ResultAsync<U, F>): ResultAsync<T | U, ExcludeReasonTag<E, ErrorTag, ReasonTag> | F>;
+  catchReasons<const ErrorTag extends TagsWithReasonOf<E>, const Handlers extends object>(errorTag: ErrorTag, handlers: Handlers & ResultAsyncCatchReasonHandlers<E, ErrorTag, Handlers>): ResultAsync<T | HandlerOk<CatchReasonHandlerResult<Handlers>>, ExcludeReasonTag<E, ErrorTag, keyof Handlers & string> | HandlerErr<CatchReasonHandlerResult<Handlers>>>;
+  unwrapReason<const ErrorTag extends TagsWithReasonOf<E>>(errorTag: ErrorTag): ResultAsync<T, ExcludeTag<E, ErrorTag> | ReasonsOf<E, ErrorTag>>;
   match<A, B = A>(handlers: MatchHandlers$1<T, E, A, B>): Promise<A | B>;
   match<A, B = A>(ok: (t: T) => A, fnErr: (e: E) => B): Promise<A | B>;
   matchTags<A, const Handlers extends object>(ok: (t: T) => A, handlers: Handlers & MatchTagHandlers<E, Handlers>): Promise<A | MatchTagHandlerResult<Handlers>>;
@@ -619,6 +747,18 @@ type TraverseAsync<T, Depth extends number = 5> = IsLiteralArray<T> extends 1 ?
 type TraverseWithAllErrorsAsync<T, Depth extends number = 5> = TraverseAsync<T, Depth> extends ResultAsync<infer Oks, infer Errs> ? ResultAsync<Oks, Errs[]> : never;
 type Writable<T> = T extends readonly unknown[] ? [...T] : T;
 //#endregion
+//#region src/redacted.d.ts
+type Redacted<T> = string & {
+  readonly __resultarRedacted: true;
+  readonly __resultarRedactedType?: T;
+  readonly label: string | undefined;
+  toJSON(): string;
+  toString(): string;
+};
+declare const redact: <T>(value: T, label?: string) => Redacted<T>;
+declare const isRedacted: (value: unknown) => value is Redacted<unknown>;
+declare const revealRedacted: <T>(value: Redacted<T>) => T;
+//#endregion
 //#region src/tagged-error.d.ts
 type Alpha = "a" | "b" | "c" | "d" | "e" | "f" | "g" | "h" | "i" | "j" | "k" | "l" | "m" | "n" | "o" | "p" | "q" | "r" | "s" | "t" | "u" | "v" | "w" | "x" | "y" | "z" | "A" | "B" | "C" | "D" | "E" | "F" | "G" | "H" | "I" | "J" | "K" | "L" | "M" | "N" | "O" | "P" | "Q" | "R" | "S" | "T" | "U" | "V" | "W" | "X" | "Y" | "Z" | "_";
 type Digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9";
@@ -665,9 +805,17 @@ type TaggedErrorClass<Tag extends string, MessageTemplate extends string, Base e
   err<This extends new (...args: TaggedErrorConstructorArgs<MessageTemplate>) => Error>(this: This, ...args: TaggedErrorConstructorArgs<MessageTemplate>): ErrResult<never, ErrorClassInstance<This>>;
   is(value: unknown): value is TaggedErrorInstance<Tag, MessageTemplate, Base>;
 };
-type TaggedEnum<Members extends Record<string, Record<PropertyKey, unknown>>> = { readonly [Tag in keyof Members]: Readonly<Members[Tag]> & {
+type TaggedEnum<Members extends Record<string, object>> = { readonly [Tag in keyof Members]: Readonly<Members[Tag]> & {
   readonly _tag: Tag;
 } }[keyof Members];
+type TaggedEnumMember<Members extends Record<string, object>, Tag extends keyof Members> = Readonly<Members[Tag]> & {
+  readonly _tag: Tag;
+};
+type TaggedEnumConstructor<Members extends Record<string, object>, Tag extends keyof Members> = keyof Members[Tag] extends never ? (props?: Readonly<Members[Tag]>) => TaggedEnumMember<Members, Tag> : (props: Readonly<Members[Tag]>) => TaggedEnumMember<Members, Tag>;
+type TaggedEnumFactory<Members extends Record<string, object>> = { readonly [Tag in keyof Members]: TaggedEnumConstructor<Members, Tag> } & {
+  $is<Tag extends keyof Members>(tag: Tag, value: unknown): value is TaggedEnumMember<Members, Tag>;
+  $match<ReturnType>(value: TaggedEnum<Members>, handlers: { readonly [Tag in keyof Members]: (value: TaggedEnumMember<Members, Tag>) => ReturnType }): ReturnType;
+};
 type TaggedErrorLike = Error & {
   readonly _tag: string;
 };
@@ -689,8 +837,9 @@ declare const findCause: <T extends Error>(error: Error, ErrorClass: ErrorClass<
 declare function createTaggedError<const Tag extends string, const MessageTemplate extends string = typeof defaultMessageTemplate, Base extends Error = Error>(options: Omit<TaggedErrorOptions<Tag, MessageTemplate, Base>, "message"> & {
   readonly message?: RejectReservedTemplateVariables<MessageTemplate>;
 }): TaggedErrorClass<Tag, MessageTemplate, Base>;
+declare const taggedEnum: <Members extends Record<string, object>>() => TaggedEnumFactory<Members>;
 declare const matchError: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: MatchHandlers<ErrorType, ReturnType>) => ReturnType;
 declare const matchErrorPartial: <ErrorType extends Error, ReturnType>(error: ErrorType, handlers: PartialMatchHandlers<ErrorType, ReturnType>, fallback: (error: ErrorType) => ReturnType) => ReturnType;
 //#endregion
-export { DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, Result, ResultAsync, type ResultOperations, type SafeTryAsyncOptions, type SafeTryOptions, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isError, matchError, matchErrorPartial, ok, okAsync, safeTry, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
+export { AbortError, DisposableResult, DisposableResultAsync, type ErrResult, type OkResult, type Redacted, Result, ResultAsync, type ResultAsyncAbortSignal, type ResultAsyncConcurrency, type ResultAsyncRaceHandle, type ResultAsyncRaceTask, type ResultAsyncResourceAcquire, type ResultAsyncResourceEffect, type ResultAsyncResourceRelease, type ResultAsyncResourceReleaseContext, type ResultAsyncResourceUse, type ResultAsyncRetryContext, type ResultAsyncRetryOptions, type ResultAsyncRetryOrElseOptions, type ResultAsyncRetryTask, type ResultAsyncTimeoutOptions, type ResultAsyncWithResourceOptions, type ResultOperations, type SafeTryAsyncOptions, type SafeTryOptions, type StrictResult, type StrictResultAsync, type TaggedEnum, type TaggedEnumFactory, type TaggedErrorClass, type TaggedErrorInstance, type TaggedErrorOptions, type TryResultAsyncOptions, type TryResultOptions, createTaggedError, tryResult as default, tryResult as try, tryResult, err, errAsync, findCause, fromPromise, fromSafePromise, fromThrowable, fromThrowableAsync, isAbortError, isError, isRedacted, matchError, matchErrorPartial, ok, okAsync, redact, revealRedacted, safeTry, taggedEnum, tryResultAsync as tryAsync, tryResultAsync, tryCatch, tryCatchAsync, unit, unitAsync };
 //# sourceMappingURL=index.d.ts.map