Feature: Result.tapEither/Async

src/result.ts

@@ -3,6 +3,7 @@ import { Unit } from './unit.js';
 import {
   Action,
   ActionOfT,
+  AsyncAction,
   AsyncActionOfT,
   ErrorHandler,
   FunctionOfT,
@@ -850,6 +851,26 @@ export class Result<TValue = Unit, TError = string> {
     return this;
   }
 
+  /**
+   * Executes the action on both success and failure.
+   * @param action a function
+   * @returns the current Result
+   */
+  tapEither(action: Action): Result<TValue, TError> {
+    action();
+
+    return this;
+  }
+
+  /**
+   * Executes the asynchronous action on both success and failure.
+   * @param action a function
+   * @returns the current Result wrapped in a ResultAsync
+   */
+  tapEitherAsync(action: AsyncAction): ResultAsync<TValue, TError> {
+    return ResultAsync.from<TValue, TError>(action().then(() => this));
+  }
+
   /**
    * Maps a successful Result's value to a new value,
    * or a failed Result's error to a new value

src/resultAsync.ts

@@ -1,6 +1,7 @@
 import { Result } from './result.js';
 import { Unit } from './unit.js';
 import {
+  Action,
   ActionOfT,
   AsyncAction,
   AsyncActionOfT,
@@ -558,6 +559,32 @@ export class ResultAsync<TValue = Unit, TError = string> {
     );
   }
 
+  /**
+   * Executes the given async action if the ResultAsync is successful or failed
+   * @param action an async function
+   * @returns the current ResultAsync wrapping the inner Result
+   */
+  tapEither(asyncAction: AsyncAction): ResultAsync<TValue, TError>;
+  /**
+   * Executes the given action if the ResultAsync is successful or failed
+   * @param action a function
+   * @returns the current ResultAsync wrapping the inner Result
+   */
+  tapEither(action: Action): ResultAsync<TValue, TError>;
+  tapEither(action: Action | AsyncAction): ResultAsync<TValue, TError> {
+    return new ResultAsync(
+      this.value.then(async (originalResult) => {
+        const actionResult = action();
+
+        if (actionResult instanceof Promise) {
+          await actionResult;
+        }
+
+        return originalResult;
+      })
+    );
+  }
+
   /**
    *
    * @param matcher

test/result/tapEither.spec.ts

@@ -0,0 +1,23 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('tapEither', () => {
+    test('will execute the given action if the Result is successful', () => {
+      let wasCalled = false;
+      const sut = Result.success(1);
+
+      sut.tapEither(() => (wasCalled = true));
+
+      expect(wasCalled).toBe(true);
+    });
+
+    test('will execute the given action if the Result is a failure', () => {
+      let wasCalled = false;
+      const sut = Result.failure<number>('error');
+
+      sut.tapEither(() => (wasCalled = true));
+
+      expect(wasCalled).toBe(true);
+    });
+  });
+});

test/result/tapEitherAsync.spec.ts

@@ -0,0 +1,35 @@
+import { Result } from '@/src/result';
+
+describe('Result', () => {
+  describe('tapEitherAsync', () => {
+    describe('promise', () => {
+      test('will execute the asynchronous action if the Result is successful', async () => {
+        let wasCalled = false;
+        const sut = Result.success(1);
+
+        const asyncAction = () => {
+          wasCalled = true;
+          return Promise.resolve();
+        };
+
+        await sut.tapEitherAsync(asyncAction).toPromise();
+
+        expect(wasCalled).toBe(true);
+      });
+
+      test('will execute the asynchronous action if the Result is a failure', async () => {
+        let wasCalled = false;
+        const sut = Result.failure<number>('error');
+
+        const asyncAction = () => {
+          wasCalled = true;
+          return Promise.resolve();
+        };
+
+        await sut.tapEitherAsync(asyncAction).toPromise();
+
+        expect(wasCalled).toBe(true);
+      });
+    });
+  });
+});

test/resultAsync/tapEither.spec.ts

@@ -0,0 +1,53 @@
+import { ResultAsync } from '@/src/resultAsync';
+
+describe('ResultAsync', () => {
+  describe('tapEither', () => {
+    test('executes the action with a failed ResultAsync', async () => {
+      let wasCalled = false;
+      const sut = ResultAsync.failure<number>('error');
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+        })
+        .toPromise();
+
+      expect(result).toFailWith('error');
+      expect(wasCalled).toBe(true);
+    });
+
+    test('executes the action with a successful ResultAsync', async () => {
+      const value = 1;
+      let wasCalled = false;
+
+      const sut = ResultAsync.success(value);
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+        })
+        .toPromise();
+
+      expect(result).toSucceedWith(1);
+      expect(wasCalled).toBe(true);
+    });
+
+    test('executes the async action with a successful ResultAsync', async () => {
+      const value = 1;
+      let wasCalled = false;
+
+      const sut = ResultAsync.success(value);
+
+      const result = await sut
+        .tapEither(() => {
+          wasCalled = true;
+
+          return Promise.resolve();
+        })
+        .toPromise();
+
+      expect(result).toSucceedWith(1);
+      expect(wasCalled).toBe(true);
+    });
+  });
+});