feat: update rambda dependency to version 10.3.4 and enhance type safety in Either, Maybe, and Result utilities

Author: richecr

bun.lock

@@ -599,3 +599,97 @@ errors.forEach((err) => console.error(err));
 
 ---
 
+## Common Patterns
+
+### Discriminated union errors
+
+```ts
+import { pipe } from 'rambda';
+import { left, match, type Either } from 'holo-fn/either';
+
+type User = {
+  name: string;
+  email: string;
+};
+
+type ValidationError =
+  | { type: 'INVALID_EMAIL'; email: string }
+  | { type: 'TOO_SHORT'; minLength: number }
+  | { type: 'REQUIRED'; field: string };
+
+const result: Either<ValidationError, User> = left({
+  type: 'INVALID_EMAIL',
+  email: 'bad@email',
+});
+
+const message = pipe(
+  result,
+  match({
+    left: (err) => {
+      switch (err.type) {
+        case 'INVALID_EMAIL':
+          return `Invalid email: ${err.email}`;
+        case 'TOO_SHORT':
+          return `Must be at least ${err.minLength} characters`;
+        case 'REQUIRED':
+          return `Field ${err.field} is required`;
+      }
+    },
+    right: (user) => `Success: ${user.name}`,
+  })
+);
+```
+
+### Batch operations with error tracking
+
+```ts
+import { pipe } from 'rambda';
+import { all, left, match, right } from 'holo-fn/either';
+
+type AddressData = {
+  street: string;
+  city: string;
+  zip: string;
+};
+
+type UserData = {
+  email: string;
+  age: number;
+  address: AddressData;
+};
+
+const validateEmail = (email: string) => (email.includes('@') ? right(email) : left('Invalid email'));
+
+const validateAge = (age: number) => (age >= 18 ? right(age) : left('Must be 18+'));
+
+const validateAddress = (address: AddressData) => {
+  if (!address.street || !address.city || !address.zip) {
+    return left('Incomplete address');
+  }
+  return right(address);
+};
+
+const validateForm = (data: UserData) =>
+  pipe(
+    all([validateEmail(data.email), validateAge(data.age), validateAddress(data.address)]),
+    match({
+      left: (err) => `Validation failed: ${err}`,
+      right: ([email, age, address]) =>
+        `Validation succeeded: ${email}, ${age}, ${address.street}, ${address.city}, ${address.zip}`,
+    })
+  );
+
+console.log(
+  validateForm({
+    email: '[email protected]',
+    age: 25,
+    address: {
+      street: '123 Main St',
+      city: 'Anytown',
+      zip: '12345',
+    },
+  })
+);
+```
+
+---

docs/either/index.md

@@ -337,3 +337,72 @@ console.log(result3.unwrapOr([])); // []
 
 ---
 
+## Common Patterns
+
+### Combining multiple Maybes
+
+When you need to work with multiple `Maybe` values:
+
+```ts
+import { pipe } from 'rambda';
+import { all, just, match } from 'holo-fn/maybe';
+
+const name = just('Test User');
+const age = just(25);
+const email = just('[email protected]');
+
+const user = pipe(
+  all([name, age, email]),
+  match({
+    just: ([n, a, e]) => ({ name: n, age: a, email: e }),
+    nothing: () => null,
+  })
+);
+
+console.log(user);
+// Output: { name: 'Test User', age: 25, email: '[email protected]' }
+
+```
+
+### Conditional logic with predicates
+
+```ts
+import { pipe } from 'rambda';
+import { just, match } from 'holo-fn/maybe';
+
+const value = just(42);
+
+const category = pipe(
+  value,
+  match({
+    just: (v) => {
+      if (v > 100) return 'big';
+      if (v > 50) return 'medium';
+      return 'small';
+    },
+    nothing: () => 'unknown',
+  })
+);
+
+console.log(`The number is categorized as: ${category}`);
+```
+
+### Chaining operations with early exit
+
+```ts
+import { pipe } from 'rambda';
+import { chain, filter, fromNullable, map } from 'holo-fn/maybe';
+
+const user: { email?: string } | null = { email: '[email protected]' };
+
+const result = pipe(
+  fromNullable(user),
+  chain((u) => fromNullable(u.email)),
+  filter((email) => email.includes('@')),
+  map((email) => email.toLowerCase())
+);
+
+console.log(result); // Just('[email protected]')
+```
+
+---

docs/maybe/index.md

@@ -495,3 +495,59 @@ failed.forEach((err) => console.error(err));
 
 ---
 
+## Common Patterns
+
+### Error handling with specific error types
+
+```ts
+import { pipe } from 'rambda';
+import { err, match, type Result } from 'holo-fn/result';
+
+type ApiError = 'NOT_FOUND' | 'UNAUTHORIZED' | 'SERVER_ERROR';
+
+type User = {
+  id: number;
+  name: string;
+};
+
+const result: Result<User, ApiError> = err('NOT_FOUND');
+
+const message = pipe(
+  result,
+  match({
+    ok: (user) => `Welcome ${user.name}`,
+    err: (e) => {
+      switch (e) {
+        case 'NOT_FOUND':
+          return 'Resource not found';
+        case 'UNAUTHORIZED':
+          return 'Access denied';
+        case 'SERVER_ERROR':
+          return 'Server error occurred';
+      }
+    },
+  })
+);
+
+console.log(message);
+```
+
+### Validation pipelines
+
+```ts
+import { pipe } from 'rambda';
+import { map, ok, validate } from 'holo-fn/result';
+
+const validateAge = (age: number) =>
+  pipe(
+    ok<number, string>(age),
+    validate((n) => n >= 0, 'Age must be positive'),
+    validate((n) => n <= 150, 'Age must be realistic'),
+    validate((n) => n >= 18, 'Must be 18 or older'),
+    map((n) => ({ age: n, isAdult: true }))
+  );
+
+console.log(validateAge(25));
+```
+
+---

docs/result/index.md

@@ -45,7 +45,7 @@
     "eslint": "^9.27.0",
     "eslint-plugin-prettier": "^5.4.0",
     "eslint-plugin-security": "^3.0.1",
-    "rambda": "^10.2.0",
+    "rambda": "^10.3.4",
     "typescript-eslint": "^8.32.1"
   },
   "peerDependencies": {

package.json

@@ -169,52 +169,66 @@ export const equals =
     return either.equals(other);
   };
 
-export const all = <L, R>(eithers: Either<L, R>[]): Either<L[], R[]> => {
-  const values: R[] = [];
-  const errors: L[] = [];
+type UnwrapEitherArray<T extends Either<unknown, unknown>[]> = {
+  [K in keyof T]: T[K] extends Either<unknown, infer R> ? R : never;
+};
+
+type UnwrapLeftArray<T extends Either<unknown, unknown>[]> = {
+  [K in keyof T]: T[K] extends Either<infer L, unknown> ? L : never;
+}[number];
+
+export function all<T extends Either<unknown, unknown>[]>(
+  eithers: [...T]
+): Either<UnwrapLeftArray<T>[], UnwrapEitherArray<T>> {
+  const values: UnwrapEitherArray<T>[number][] = [];
+  const errors: UnwrapLeftArray<T>[] = [];
 
   for (const either of eithers) {
     if (either.isLeft()) {
-      errors.push(either.extract() as L);
+      errors.push(either.extract() as UnwrapLeftArray<T>);
     } else {
-      values.push(either.extract() as R);
+      values.push(either.extract() as UnwrapEitherArray<T>[number]);
     }
   }
 
   if (errors.length > 0) {
-    return new Left<L[], R[]>(errors);
+    return new Left(errors) as Either<UnwrapLeftArray<T>[], UnwrapEitherArray<T>>;
   }
 
-  return new Right<L[], R[]>(values);
-};
+  return new Right(values) as Either<UnwrapLeftArray<T>[], UnwrapEitherArray<T>>;
+}
 
-export const sequence = <L, R>(eithers: Either<L, R>[]): Either<L, R[]> => {
-  const values: R[] = [];
+export function sequence<T extends Either<unknown, unknown>[]>(
+  eithers: [...T]
+): Either<UnwrapLeftArray<T>, UnwrapEitherArray<T>> {
+  const values: UnwrapEitherArray<T>[number][] = [];
 
   for (const either of eithers) {
     if (either.isLeft()) {
-      return new Left<L, R[]>(either.extract() as L);
+      return new Left(either.extract() as UnwrapLeftArray<T>) as Either<UnwrapLeftArray<T>, UnwrapEitherArray<T>>;
     }
 
-    values.push(either.extract() as R);
+    values.push(either.extract() as UnwrapEitherArray<T>[number]);
   }
 
-  return new Right<L, R[]>(values);
-};
+  return new Right(values) as Either<UnwrapLeftArray<T>, UnwrapEitherArray<T>>;
+}
 
-export const partition = <L, R>(eithers: Either<L, R>[]): { lefts: L[]; rights: R[] } => {
+export function partition<T extends Either<unknown, unknown>[]>(
+  eithers: [...T]
+): { lefts: UnwrapLeftArray<T>[]; rights: UnwrapEitherArray<T> } {
   return eithers.reduce(
     (acc, either) => {
       if (either.isLeft()) {
-        acc.lefts.push(either.extract() as L);
+        acc.lefts.push(either.extract() as UnwrapLeftArray<T>);
       } else {
-        acc.rights.push(either.extract() as R);
+        acc.rights.push(either.extract() as UnwrapEitherArray<T>[number]);
       }
       return acc;
     },
-    { lefts: [] as L[], rights: [] as R[] }
-  );
-};
+    { lefts: [] as UnwrapLeftArray<T>[], rights: [] as UnwrapEitherArray<T>[number][] }
+  ) as { lefts: UnwrapLeftArray<T>[]; rights: UnwrapEitherArray<T> };
+}
 
 export const left = <L, R = never>(value: L): Either<L, R> => new Left(value);
 export const right = <L, R>(value: R): Either<L, R> => new Right(value);

src/either/index.ts

@@ -132,19 +132,23 @@ export const equals =
     return maybe.equals(other);
   };
 
-export const all = <T>(maybes: Maybe<T>[]): Maybe<T[]> => {
-  const values: T[] = [];
+type UnwrapMaybeArray<T extends Maybe<unknown>[]> = {
+  [K in keyof T]: T[K] extends Maybe<infer V> ? V : never;
+};
+
+export function all<T extends Maybe<unknown>[]>(maybes: [...T]): Maybe<UnwrapMaybeArray<T>> {
+  const values: UnwrapMaybeArray<T>[number][] = [];
 
   for (const maybe of maybes) {
     if (maybe.isNothing()) {
-      return new Nothing<T[]>();
+      return new Nothing() as Maybe<UnwrapMaybeArray<T>>;
     }
 
-    values.push(maybe.extract());
+    values.push(maybe.extract() as UnwrapMaybeArray<T>[number]);
   }
 
-  return new Just(values);
-};
+  return new Just(values) as Maybe<UnwrapMaybeArray<T>>;
+}
 
 export const just = <T>(value: T): Maybe<T> => new Just(value);
 export const nothing = <T = never>() => new Nothing<T>();