Added Traverse applicative

Author: benoitlahoz

packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assemblerjs/core",
-  "version": "0.8.31",
+  "version": "0.9.1",
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",

packages/core/src/applicative-like/index.ts

@@ -0,0 +1 @@
+export * from './traverse.applicative';

packages/core/src/applicative-like/traverse.applicative.spec.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'vitest';
+import { asyncMap } from '@/loop.utils';
+import { Task } from '../monad-like/task.monad';
+import { Maybe } from '../monad-like/maybe.monad';
+import { Traverse } from './traverse.applicative';
+
+describe('Traverse', () => {
+  it('should apply functions to values and collect results', async () => {
+    const traverse = Traverse.of([(x: number) => x * 2, (x: number) => x + 1]);
+    const results = await traverse.ap([1, 2, 3]);
+    expect(results).toEqual([2, 4, 6, 2, 3, 4]);
+  });
+
+  it('should handle errors during function application', async () => {
+    const traverse = Traverse.of([
+      (x: number) => x * 2,
+      (_: number) => {
+        throw new Error('Test Error');
+      },
+    ]);
+    const results = await traverse.ap([1, 2]);
+    expect(results).toEqual([
+      2,
+      4,
+      new Error('Test Error'),
+      new Error('Test Error'),
+    ]);
+  });
+
+  it('should handle async functions', async () => {
+    const traverse = Traverse.of([
+      async (x: number) => x * 2,
+      async (x: number) => x + 1,
+    ]);
+    const results = await traverse.ap([1, 2]);
+    expect(results).toEqual([2, 4, 2, 3]);
+  });
+
+  it('should work with Task monad', async () => {
+    const task = (x: number) => Task.of(() => 42 + x);
+    const traverse = Traverse.of([task]);
+    const apply = await traverse.ap([1]);
+    const result = await asyncMap(apply)(async (fn) =>
+      (await fn.fork()).unwrap()
+    );
+    expect(result).toEqual([43]);
+  });
+
+  it('should work with Maybe monad', async () => {
+    const maybeFn = (x: number) => Maybe.of(x > 0 ? x * 2 : null);
+    const traverse = Traverse.of([maybeFn]);
+    const maybes: Array<Maybe<number | null>> = (await traverse.ap([
+      1, -1, 2,
+    ])) as Maybe<number | null>[];
+    const results = maybes.map((maybe) => maybe.unwrapOr(null));
+    expect(results).toEqual([2, null, 4]);
+  });
+
+  it('should map functions correctly', () => {
+    const traverse = Traverse.of([(x: number) => x * 2, (x: number) => x + 1]);
+    const mappedTraverse = traverse.map(
+      (fn: Function) => (x: number) => fn(x) + 1
+    );
+    const results = mappedTraverse.getFunctions().map((fn) => fn(2));
+    expect(results).toEqual([5, 4]);
+  });
+
+  it('should chain multiple Traverse operations', () => {
+    const traverse = Traverse.of([(x: number) => x * 2, (x: number) => x + 1]);
+    const chainedTraverse = traverse.chain((fn: Function) =>
+      Traverse.of([(x: number) => fn(x) + 3])
+    );
+    const results = chainedTraverse.getFunctions().map((fn) => fn(2));
+    expect(results).toEqual([7, 6]);
+  });
+
+  it('should call the function with undefined value if no values are provided', async () => {
+    const traverse = Traverse.of([() => 2 * 2, () => 1 + 1]);
+    const results = await traverse.ap();
+    expect(results).toEqual([4, 2]);
+  });
+
+  it('should call the function with undefined value and async functions in input', async () => {
+    const traverse = Traverse.of([
+      async () =>
+        await new Promise<number>((resolve) =>
+          setTimeout(() => resolve(2 * 2), 10)
+        ),
+      async () =>
+        await new Promise<number>((resolve) =>
+          setTimeout(() => resolve(1 + 1), 20)
+        ),
+      async () =>
+        await new Promise<number | Error>((reject) =>
+          setTimeout(() => reject(new Error('Test Error')), 30)
+        ),
+    ]);
+    const results = await traverse.ap();
+    expect(results).toEqual([4, 2, new Error('Test Error')]);
+  });
+
+  it('should handle empty functions array', async () => {
+    const traverse = Traverse.of([]);
+    const results = await traverse.ap([1, 2, 3]);
+    expect(results).toEqual([]);
+  });
+});

packages/core/src/applicative-like/traverse.applicative.ts

@@ -0,0 +1,88 @@
+import { isAsync, isPromise } from '../type.validator';
+
+/**
+ * Traverse class implementing applicative functor pattern for arrays
+ * Allows applying an array of functions to arrays of values, collecting results
+ */
+export class Traverse<T, U> {
+  /**
+   * Creates a new Traverse instance wrapping an array of functions.
+   * Handles both sync and async functions.
+   * @param functions Array of functions to wrap (sync or async)
+   * @returns New Traverse instance
+   */
+  static of<T, U>(
+    functions: Array<(value: T) => U | Promise<U>>
+  ): Traverse<T, U | Promise<U>> {
+    return new Traverse(functions);
+  }
+
+  private constructor(
+    private readonly functions: Array<(value: T) => U | Promise<U>>
+  ) {}
+
+  /**
+   * Applies the wrapped functions to an array of values.
+   * Handles both sync and async functions, returning a Promise of all results.
+   * @param values Array of values to apply functions to
+   * @returns Promise resolving to array of results from applying functions to values
+   */
+  async ap(values?: T[]): Promise<U[]> {
+    const results: U[] = [];
+    const valuesToUse = values || [undefined as T];
+
+    for (const fn of this.functions) {
+      for (const val of valuesToUse) {
+        try {
+          let res: U;
+          if (isAsync(fn) || isPromise(fn)) {
+            res = (await fn(val)) as U;
+          } else {
+            res = fn(val) as U;
+          }
+          results.push(res);
+        } catch (err) {
+          results.push(err as U);
+        }
+      }
+    }
+
+    return results as U[];
+  }
+
+  /**
+   * Maps a function over the wrapped functions
+   * @param fn Function to transform each function
+   * @returns New Traverse instance with transformed functions
+   */
+  map<V>(
+    fn: (func: (value: T) => U | Promise<U>) => (value: T) => V | Promise<V>
+  ): Traverse<T, V | Promise<V>> {
+    return new Traverse(this.functions.map(fn));
+  }
+
+  /**
+   * Gets the wrapped functions
+   * @returns Array of wrapped functions
+   */
+  getFunctions(): ((value: T) => U | Promise<U>)[] {
+    return [...this.functions];
+  }
+
+  /**
+   * Chains multiple Traverse operations
+   * @param fn Function that returns a Traverse instance
+   * @returns Flattened Traverse instance
+   */
+  chain<V>(
+    fn: (func: (value: T) => U | Promise<U>) => Traverse<T, V | Promise<V>>
+  ): Traverse<T, V | Promise<V>> {
+    const results: ((value: T) => V | Promise<V>)[] = [];
+    for (const func of this.functions) {
+      results.push(
+        ...(fn(func).getFunctions() as ((value: T) => V | Promise<V>)[])
+      );
+    }
+    return new Traverse(results);
+  }
+}

packages/core/src/index.ts

@@ -12,6 +12,7 @@ export * from './proxy.utils';
 export * from './string.formatter';
 
 export * from './monad-like';
+export * from './applicative-like';
 
 export * from './decorators/class/singleton.decorator';
 export * from './decorators/class/static-implements.decorator';