feat: improve zipWidth element count (#210)

Author: patrickmichalina

src/maybe/maybe.interface.ts

@@ -534,25 +534,80 @@ export interface IMaybe<T> extends IMonad<T> {
   flatMapMany<R>(fn: (val: NonNullable<T>) => Promise<R>[]): Promise<IMaybe<NonNullable<R>[]>>
 
   /**
-   * Combines this Maybe with another Maybe using a combiner function.
-   * 
-   * If both Maybes are Some, applies the function to their values and returns
-   * a new Some containing the result. If either is None, returns None.
-   * 
+   * Combines this Maybe with one or more other Maybes using a combiner function.
+   *
+   * If all Maybes are Some, applies the function to their values and returns
+   * a new Some containing the result. If any is None, returns None.
+   *
    * @typeParam U - The type of the value in the other Maybe
    * @typeParam R - The type of the combined result
    * @param other - Another Maybe to combine with this one
    * @param fn - A function that combines the values from both Maybes
-   * @returns A new Maybe containing the combined result if both inputs are Some, otherwise None
-   * 
+   * @returns A new Maybe containing the combined result if all inputs are Some, otherwise None
+   *
    * @example
-   * // Combine user name and email into a display string
+   * // Combine two values
    * const name = maybe(user.name);
    * const email = maybe(user.email);
-   * 
+   *
    * const display = name.zipWith(email, (name, email) => `${name} <${email}>`);
-   * // Some("John Doe <[email protected]>") if both name and email exist
+   * // Some("John Doe <[email protected]>") if both exist
    * // None if either is missing
+   *
+   * @example
+   * // Combine three values
+   * const firstName = maybe(user.firstName);
+   * const lastName = maybe(user.lastName);
+   * const email = maybe(user.email);
+   *
+   * const contact = firstName.zipWith(lastName, email, (first, last, email) => ({
+   *   fullName: `${first} ${last}`,
+   *   email
+   * }));
+   * // Some({ fullName: "John Doe", email: "john@example.com" }) if all exist
+   * // None if any is missing
+   *
+   * @example
+   * // Combine many values
+   * const result = a.zipWith(b, c, d, e, (a, b, c, d, e) => a + b + c + d + e);
    */
-  zipWith<U extends NonNullable<unknown>, R>(other: IMaybe<U>, fn: (a: NonNullable<T>, b: U) => NonNullable<R>): IMaybe<R>
+  zipWith<U extends NonNullable<unknown>, R>(
+    other: IMaybe<U>,
+    fn: (a: NonNullable<T>, b: U) => NonNullable<R>
+  ): IMaybe<R>
+
+  zipWith<U extends NonNullable<unknown>, V extends NonNullable<unknown>, R>(
+    m1: IMaybe<U>,
+    m2: IMaybe<V>,
+    fn: (a: NonNullable<T>, b: U, c: V) => NonNullable<R>
+  ): IMaybe<R>
+
+  zipWith<U extends NonNullable<unknown>, V extends NonNullable<unknown>, W extends NonNullable<unknown>, R>(
+    m1: IMaybe<U>,
+    m2: IMaybe<V>,
+    m3: IMaybe<W>,
+    fn: (a: NonNullable<T>, b: U, c: V, d: W) => NonNullable<R>
+  ): IMaybe<R>
+
+  zipWith<U extends NonNullable<unknown>, V extends NonNullable<unknown>, W extends NonNullable<unknown>, X extends NonNullable<unknown>, R>(
+    m1: IMaybe<U>,
+    m2: IMaybe<V>,
+    m3: IMaybe<W>,
+    m4: IMaybe<X>,
+    fn: (a: NonNullable<T>, b: U, c: V, d: W, e: X) => NonNullable<R>
+  ): IMaybe<R>
+
+  zipWith<U extends NonNullable<unknown>, V extends NonNullable<unknown>, W extends NonNullable<unknown>, X extends NonNullable<unknown>, Z extends NonNullable<unknown>, R>(
+    m1: IMaybe<U>,
+    m2: IMaybe<V>,
+    m3: IMaybe<W>,
+    m4: IMaybe<X>,
+    m5: IMaybe<Z>,
+    fn: (a: NonNullable<T>, b: U, c: V, d: W, e: X, f: Z) => NonNullable<R>
+  ): IMaybe<R>
+
+  // Variadic overload for 5+ Maybes
+  zipWith<R>(
+    ...args: [...IMaybe<NonNullable<unknown>>[], (...values: NonNullable<unknown>[]) => NonNullable<R>]
+  ): IMaybe<R>
 }

src/maybe/maybe.spec.ts

@@ -858,13 +858,110 @@ describe('Maybe', () => {
     it('should return None if both values are None', () => {
       const first = maybe<string>()
       const second = maybe<string>()
-      
+
       const result = first.zipWith(second, (a, b) => `${a}, ${b}!`)
-      
+
+      expect(result.isNone()).toBe(true)
+    })
+
+    it('should combine three Some values', () => {
+      const a = maybe(1)
+      const b = maybe(2)
+      const c = maybe(3)
+
+      const result = a.zipWith(b, c, (x, y, z) => x + y + z)
+
+      expect(result.isSome()).toBe(true)
+      expect(result.valueOr(0)).toBe(6)
+    })
+
+    it('should return None if any of three values is None', () => {
+      const a = maybe(1)
+      const b = maybe<number>()
+      const c = maybe(3)
+
+      const result = a.zipWith(b, c, (x, y, z) => x + y + z)
+
+      expect(result.isNone()).toBe(true)
+    })
+
+    it('should combine four Some values', () => {
+      const a = maybe('a')
+      const b = maybe('b')
+      const c = maybe('c')
+      const d = maybe('d')
+
+      const result = a.zipWith(b, c, d, (w, x, y, z) => w + x + y + z)
+
+      expect(result.isSome()).toBe(true)
+      expect(result.valueOr('')).toBe('abcd')
+    })
+
+    it('should return None if any of four values is None', () => {
+      const a = maybe('a')
+      const b = maybe('b')
+      const c = maybe<string>()
+      const d = maybe('d')
+
+      const result = a.zipWith(b, c, d, (w, x, y, z) => w + x + y + z)
+
       expect(result.isNone()).toBe(true)
     })
+
+    it('should combine five Some values', () => {
+      const a = maybe(1)
+      const b = maybe(2)
+      const c = maybe(3)
+      const d = maybe(4)
+      const e = maybe(5)
+
+      const result = a.zipWith(b, c, d, e, (v1, v2, v3, v4, v5) => v1 + v2 + v3 + v4 + v5)
+
+      expect(result.isSome()).toBe(true)
+      expect(result.valueOr(0)).toBe(15)
+    })
+
+    it('should return None if any of five values is None', () => {
+      const a = maybe(1)
+      const b = maybe(2)
+      const c = maybe(3)
+      const d = maybe(4)
+      const e = maybe<number>()
+
+      const result = a.zipWith(b, c, d, e, (v1, v2, v3, v4, v5) => v1 + v2 + v3 + v4 + v5)
+
+      expect(result.isNone()).toBe(true)
+    })
+
+    it('should return None if any of six values is None', () => {
+      const a = maybe(1)
+      const b = maybe(2)
+      const c = maybe(3)
+      const d = maybe(4)
+      const e = maybe(5)
+      const f = maybe<number>()
+
+      const result = a.zipWith(b, c, d, e, f, (v1, v2, v3, v4, v5, v6) => v1 + v2 + v3 + v4 + v5 + v6)
+
+      expect(result.isNone()).toBe(true)
+    })
+
+    it('should work with mixed types', () => {
+      const name = maybe('John')
+      const age = maybe(30)
+      const active = maybe(true)
+
+      const result = name.zipWith(age, active, (n, a, act) => ({ name: n, age: a, active: act }))
+
+      expect(result.isSome()).toBe(true)
+      expect(result.valueOr({ name: '', age: 0, active: false })).toEqual({
+        name: 'John',
+        age: 30,
+        active: true
+      })
+    })
   })
-  
+
   describe('flatMapMany', () => {
     it('should execute multiple promises in parallel when Some', async () => {
       const source = maybe(42)

src/maybe/maybe.ts

@@ -301,7 +301,23 @@ export class Maybe<T> implements IMaybe<T> {
       .catch(() => new Maybe<NonNullable<R>[]>())
   }
 
-  public zipWith<U extends NonNullable<unknown>, R>(other: IMaybe<U>, fn: (a: NonNullable<T>, b: U) => NonNullable<R>): IMaybe<R> {
-    return this.flatMap(a => other.map(b => fn(a, b)))
+  public zipWith<R>(...args: unknown[]): IMaybe<R> {
+    if (this.isNone()) {
+      return new Maybe<R>()
+    }
+
+    const fn = args[args.length - 1] as (...values: unknown[]) => NonNullable<R>
+    const maybes = args.slice(0, -1) as IMaybe<unknown>[]
+
+    const values: unknown[] = [this.value]
+
+    for (const m of maybes) {
+      if (m.isNone()) {
+        return new Maybe<R>()
+      }
+      values.push(m.valueOrThrow())
+    }
+
+    return new Maybe<R>(fn(...values))
   }
 }