feat(monad): add future monad

Author: myugen

src/complete/completable.ts

@@ -0,0 +1,3 @@
+export interface Completable<T> {
+  complete<S>(onSuccess: (value: T) => S, onFailure: (error: Error) => S): Promise<S>;
+}

src/complete/index.ts

@@ -0,0 +1 @@
+export { Completable } from './completable';

src/either/either.ts

@@ -17,13 +17,6 @@ abstract class Either<L, R> implements Monad<R>, Matchable<R, L> {
     );
   }
 
-  static complete<R>(completable: Completable<R>): AsyncEither<Error, R> {
-    return completable.complete<Either<Error, R>>(
-      (value: R) => Either.right(value),
-      (error: Error) => Either.left(error)
-    );
-  }
-
   static catch<T>(execute: () => T): Either<Error, T> {
     try {
       return Either.right(execute());
@@ -115,4 +108,4 @@ class Right<L, R> extends Either<L, R> {
   }
 }
 
-export { Either, Right, Left, AsyncEither };
+export { Either, Right, Left };

src/future/future.test.ts

@@ -0,0 +1,84 @@
+import { assert, describe, expect, it, vi } from 'vitest';
+import { Future } from './future';
+
+describe('Future monad', () => {
+  it.each([
+    {
+      completionType: 'success',
+      action: () => Promise.resolve(2),
+      expected: {
+        ifSuccess: (value: number) => expect(value).toBe(2),
+        ifFailure: (_) => assert.fail('Error should not be thrown'),
+      },
+    },
+    {
+      completionType: 'failure',
+      action: () => Promise.reject<number>(new Error('Error')),
+      expected: {
+        ifSuccess: () => assert.fail('Value should not be emitted'),
+        ifFailure: (error: Error) => expect(error).toEqual(new Error('Error')),
+      },
+    },
+  ])('should handle $completionType completion', async ({ action, expected }) => {
+    const future = Future.of(action);
+    await future.complete(expected.ifSuccess, expected.ifFailure);
+  });
+
+  it.each([
+    {
+      completionType: 'Success',
+      future: Future.of(() => Promise.resolve(2)),
+      expected: {
+        ifSuccess: (value: number) => expect(value).toBe(4),
+        ifFailure: (_) => assert.fail('Error should not be thrown'),
+      },
+    },
+    {
+      completionType: 'Failure',
+      future: Future.of(() => Promise.reject<number>(new Error('Error'))),
+      expected: {
+        ifSuccess: () => assert.fail('Value should not be emitted'),
+        ifFailure: (error: Error) => expect(error).toEqual(new Error('Error')),
+      },
+    },
+  ])('$completionType completion should handle map correctly', async ({ future, expected }) => {
+    const actual = future.map((value) => value * 2);
+    await actual.complete(expected.ifSuccess, expected.ifFailure);
+  });
+
+  it.each([
+    {
+      completionType: 'Success',
+      future: Future.of(() => Promise.resolve(2)),
+      expected: {
+        ifSuccess: (value: number) => expect(value).toBe(4),
+        ifFailure: (error: Error) => assert.fail('Error should not be thrown'),
+      },
+    },
+    {
+      completionType: 'Failure',
+      future: Future.of(() => Promise.reject<number>(new Error('Error'))),
+      expected: {
+        ifSuccess: () => assert.fail('Value should not be emitted'),
+        ifFailure: (error: Error) => expect(error).toEqual(new Error('Error')),
+      },
+    },
+  ])('$completionType completion should handle flatMap correctly', async ({ future, expected }) => {
+    const actual = future.flatMap((value) => Future.of(() => Promise.resolve(value * 2)));
+    await actual.complete(expected.ifSuccess, expected.ifFailure);
+  });
+
+  it('should not execute async action when a mapping is performed', async () => {
+    const asyncAction = vi.fn(async () => 2);
+    const future = Future.of(asyncAction);
+    future.map((value) => value * 2);
+    expect(asyncAction).not.toHaveBeenCalled();
+  });
+
+  it('should not execute async action when a flat mapping is performed', async () => {
+    const asyncAction = vi.fn(async () => 2);
+    const future = Future.of(asyncAction);
+    future.flatMap((value) => Future.of(() => Promise.resolve(value * 2)));
+    expect(asyncAction).not.toHaveBeenCalled();
+  });
+});

src/future/future.ts

@@ -0,0 +1,24 @@
+import { Monad } from '../monad';
+import { Completable } from '../complete';
+
+class Future<T> implements Monad<T>, Completable<T> {
+  private constructor(private readonly action: () => Promise<T>) {}
+
+  static of<T>(action: () => Promise<T>): Future<T> {
+    return new Future(action);
+  }
+
+  map<U>(transform: (value: T) => U): Future<U> {
+    return new Future<U>(() => this.action().then(transform));
+  }
+
+  flatMap<U>(transform: (value: T) => Future<U>): Future<U> {
+    return new Future<U>(() => this.action().then((value) => transform(value).action()));
+  }
+
+  complete<S>(onSuccess: (value: T) => S, onFailure: (error: Error) => S): Promise<S> {
+    return this.action().then(onSuccess).catch(onFailure);
+  }
+}
+
+export { Future };

src/future/index.ts

@@ -0,0 +1 @@
+export { Future } from './future';

src/index.ts

@@ -1,3 +1,4 @@
 export * from './either';
+export * from './future';
 export * from './option';
 export * from './try';