[fabric/core] Rename mapError to errorMap; add Result.assert utility function

packages/fabric/core/result/async-result.ts

@@ -110,21 +110,35 @@ export class AsyncResult<
   /**
    * Map a function over the error of the result.
    */
-  mapError<TMappedError extends TaggedError>(
+  errorMap<TMappedError extends TaggedError>(
     fn: (error: TError) => TMappedError,
   ): AsyncResult<TValue, TMappedError> {
     return new AsyncResult(
-      this.r.then((result) => result.mapError(fn)),
+      this.r.then((result) => result.errorMap(fn)),
     );
   }
 
   /**
-   * Taps a function if the result is a success.
-   * This is useful for side effects that do not modify the result.
+   * Execute a function if the result is not an error.
+   * The function does not affect the result.
    */
   tap(fn: (value: TValue) => void): AsyncResult<TValue, TError> {
     return new AsyncResult(
       this.r.then((result) => result.tap(fn)),
     );
   }
+
+  assert<TResultValue, TResultError extends TaggedError>(
+    fn: (value: TValue) => AsyncResult<TResultValue, TResultError>,
+  ): AsyncResult<TValue, TError | TResultError> {
+    return new AsyncResult(
+      this.r.then((result) => {
+        if (result.isError()) {
+          return result as any;
+        }
+
+        return (fn(result.unwrapOrThrow())).promise();
+      }),
+    );
+  }
 }

packages/fabric/core/result/result.ts

@@ -127,7 +127,7 @@ export class Result<TValue, TError extends TaggedError = never> {
   /**
    * Map a function over the error of the result.
    */
-  mapError<TMappedError extends TaggedError>(
+  errorMap<TMappedError extends TaggedError>(
     fn: (error: TError) => TMappedError,
   ): Result<TValue, TMappedError> {
     if (isError(this.value)) {
@@ -143,9 +143,19 @@ export class Result<TValue, TError extends TaggedError = never> {
    */
   tap(fn: (value: TValue) => void): Result<TValue, TError> {
     if (!isError(this.value)) {
+      try {
         fn(this.value as TValue);
+      } catch {
+        // do nothing
+      }
     }
 
     return this;
   }
+
+  assert<TResultValue, TResultError extends TaggedError>(
+    fn: (value: TValue) => Result<TResultValue, TResultError>,
+  ): Result<TValue, TError | TResultError> {
+    return this.flatMap((value) => fn(value).map(() => value));
+  }
 }