@effect/typeclass - npm Package Compare versions

Comparing version 0.24.34 to 0.24.35

dist/dts/Bicovariant.d.ts

@@ -26,3 +26,3 @@ import type { Kind, TypeClass, TypeLambda } from "effect/HKT";
     <E, G>(f: (e: E) => G): <R, O, A>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, G, A>;
-    <R_1, O_1, E_1, A_1, G_1>(self: Kind<F, R_1, O_1, E_1, A_1>, f: (e: E_1) => G_1): Kind<F, R_1, O_1, G_1, A_1>;
+    <R, O_1, E, A_1, G_1>(self: Kind<F, R, O_1, E, A_1>, f: (e: E) => G_1): Kind<F, R, O_1, G_1, A_1>;
 };
@@ -34,6 +34,3 @@ /**
  */
-export declare const map: <F extends TypeLambda>(F: Bicovariant<F>) => {
-    <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, B>;
-    <R_1, O_1, E_1, A_1, B_1>(self: Kind<F, R_1, O_1, E_1, A_1>, f: (a: A_1) => B_1): Kind<F, R_1, O_1, E_1, B_1>;
-};
+export declare const map: <F extends TypeLambda>(F: Bicovariant<F>) => Covariant<F>["map"];
 //# sourceMappingURL=Bicovariant.d.ts.map

dist/dts/Chainable.d.ts

@@ -19,3 +19,3 @@ import type { Kind, TypeLambda } from "effect/HKT";
     <R2, O2, E2, _>(that: Kind<F, R2, O2, E2, _>): <R1, O1, E1, A>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, A>;
-    <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, __1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, __1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, A_1>;
+    <R1, O1_1, E1_1, A_1, R2, O2_1, E2_1, __1>(self: Kind<F, R1, O1_1, E1_1, A_1>, that: Kind<F, R2, O2_1, E2_1, __1>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, A_1>;
 };
@@ -29,3 +29,3 @@ /**
     <A, R2, O2, E2, _>(f: (a: A) => Kind<F, R2, O2, E2, _>): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, A>;
-    <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, __1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, f: (a: A_1) => Kind<F, R2_1, O2_1, E2_1, __1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, A_1>;
+    <R1, O1_1, E1_1, A, R2_1, O2_1, E2_1, __1>(self: Kind<F, R1, O1_1, E1_1, A>, f: (a: A) => Kind<F, R2_1, O2_1, E2_1, __1>): Kind<F, R1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, A>;
 };
@@ -37,5 +37,5 @@ /**
 export declare const bind: <F extends TypeLambda>(F: Chainable<F>) => {
-    <N extends string, A extends object, R2, O2, E2, B>(name: Exclude<N, keyof A>, f: (a: A) => Kind<F, R2, O2, E2, B>): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, { [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
-    <R1_1, O1_1, E1_1, A_1 extends object, N_1 extends string, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, name: Exclude<N_1, keyof A_1>, f: (a: A_1) => Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, { [K_1 in N_1 | keyof A_1]: K_1 extends keyof A_1 ? A_1[K_1] : B_1; }>;
+    <N extends string, A extends object, R2, O2, E2, B>(name: Exclude<N, keyof A>, f: (a: A) => Kind<F, R2, O2, E2, B>): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B; }>;
+    <R1, O1_1, E1_1, A_1 extends object, N extends string, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1, O1_1, E1_1, A_1>, name: Exclude<N, keyof A_1>, f: (a: A_1) => Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, { [K in keyof A_1 | N]: K extends keyof A_1 ? A_1[K] : B_1; }>;
 };
 //# sourceMappingURL=Chainable.d.ts.map

dist/dts/Covariant.d.ts

@@ -31,3 +31,3 @@ import type { Kind, TypeLambda } from "effect/HKT";
     <R, O, E, A, B>(self: Kind<F, R, O, E, (a: A) => B>): (a: A) => Kind<F, R, O, E, B>;
-    <A_1, R_1, O_1, E_1, B_1>(a: A_1, self: Kind<F, R_1, O_1, E_1, (a: A_1) => B_1>): Kind<F, R_1, O_1, E_1, B_1>;
+    <A_1, R, O_1, E_1, B_1>(a: A_1, self: Kind<F, R, O_1, E_1, (a: A_1) => B_1>): Kind<F, R, O_1, E_1, B_1>;
 };
@@ -40,3 +40,3 @@ /**
     <B>(b: B): <R, O, E, _>(self: Kind<F, R, O, E, _>) => Kind<F, R, O, E, B>;
-    <R_1, O_1, E_1, __1, B_1>(self: Kind<F, R_1, O_1, E_1, __1>, b: B_1): Kind<F, R_1, O_1, E_1, B_1>;
+    <R, O_1, E_1, __1, B>(self: Kind<F, R, O_1, E_1, __1>, b: B): Kind<F, R, O_1, E_1, B>;
 };
@@ -49,4 +49,4 @@ /**
 declare const let_: <F extends TypeLambda>(F: Covariant<F>) => {
-    <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, { [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
-    <R_1, O_1, E_1, A_1 extends object, N_1 extends string, B_1>(self: Kind<F, R_1, O_1, E_1, A_1>, name: Exclude<N_1, keyof A_1>, f: (a: A_1) => B_1): Kind<F, R_1, O_1, E_1, { [K_1 in N_1 | keyof A_1]: K_1 extends keyof A_1 ? A_1[K_1] : B_1; }>;
+    <N extends string, A extends object, B>(name: Exclude<N, keyof A>, f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, { [K in keyof A | N]: K extends keyof A ? A[K] : B; }>;
+    <R, O_1, E_1, A_1 extends object, N extends string, B_1>(self: Kind<F, R, O_1, E_1, A_1>, name: Exclude<N, keyof A_1>, f: (a: A_1) => B_1): Kind<F, R, O_1, E_1, { [K in keyof A_1 | N]: K extends keyof A_1 ? A_1[K] : B_1; }>;
 };
@@ -53,0 +53,0 @@ export {

dist/dts/Filterable.d.ts

@@ -58,6 +58,6 @@ /**
     <C extends A, B extends A, A = C>(refinement: (a: A) => a is B): <R, O, E>(self: Kind<F, R, O, E, C>) => [Kind<F, R, O, E, C>, Kind<F, R, O, E, B>];
-    <B_1 extends A_1, A_1 = B_1>(predicate: (a: A_1) => boolean): <R_1, O_1, E_1>(self: Kind<F, R_1, O_1, E_1, B_1>) => [Kind<F, R_1, O_1, E_1, B_1>, Kind<F, R_1, O_1, E_1, B_1>];
-    <R_2, O_2, E_2, C_1 extends A_2, B_2 extends A_2, A_2 = C_1>(self: Kind<F, R_2, O_2, E_2, C_1>, refinement: (a: A_2) => a is B_2): [Kind<F, R_2, O_2, E_2, C_1>, Kind<F, R_2, O_2, E_2, B_2>];
-    <R_3, O_3, E_3, B_3 extends A_3, A_3 = B_3>(self: Kind<F, R_3, O_3, E_3, B_3>, predicate: (a: A_3) => boolean): [Kind<F, R_3, O_3, E_3, B_3>, Kind<F, R_3, O_3, E_3, B_3>];
+    <B_1 extends A_1, A_1 = B_1>(predicate: (a: A_1) => boolean): <R, O_1, E_1>(self: Kind<F, R, O_1, E_1, B_1>) => [Kind<F, R, O_1, E_1, B_1>, Kind<F, R, O_1, E_1, B_1>];
+    <R, O_2, E_2, C extends A_2, B_1 extends A_2, A_2 = C>(self: Kind<F, R, O_2, E_2, C>, refinement: (a: A_2) => a is B_1): [Kind<F, R, O_2, E_2, C>, Kind<F, R, O_2, E_2, B_1>];
+    <R, O_3, E_3, B_2 extends A_3, A_3 = B_2>(self: Kind<F, R, O_3, E_3, B_2>, predicate: (a: A_3) => boolean): [Kind<F, R, O_3, E_3, B_2>, Kind<F, R, O_3, E_3, B_2>];
 };
 //# sourceMappingURL=Filterable.d.ts.map

dist/dts/FlatMap.d.ts

@@ -15,3 +15,3 @@ import type { Kind, TypeClass, TypeLambda } from "effect/HKT";
  */
-export declare const flatten: <F extends TypeLambda>(F: FlatMap<F>) => <R2, O2, E2, R1, O1, E1, A>(self: Kind<F, R2, O2, E2, Kind<F, R1, O1, E1, A>>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, A>;
+export declare const flatten: <F extends TypeLambda>(F: FlatMap<F>) => <R2, O2, E2, R1, O1, E1, A>(self: Kind<F, R2, O2, E2, Kind<F, R1, O1, E1, A>>) => Kind<F, R1 & R2, O1 | O2, E1 | E2, A>;
 /**
@@ -24,3 +24,3 @@ * A variant of `flatMap` that ignores the value produced by this effect.
     <R2, O2, E2, B>(that: Kind<F, R2, O2, E2, B>): <R1, O1, E1, _>(self: Kind<F, R1, O1, E1, _>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, B>;
-    <R1_1, O1_1, E1_1, __1, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, __1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, B_1>;
+    <R1, O1_1, E1_1, __1, R2, O2_1, E2_1, B_1>(self: Kind<F, R1, O1_1, E1_1, __1>, that: Kind<F, R2, O2_1, E2_1, B_1>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, B_1>;
 };
@@ -32,4 +32,4 @@ /**
     <B, R2, O2, E2, C>(bfc: (b: B) => Kind<F, R2, O2, E2, C>): <A, R1, O1, E1>(afb: (a: A) => Kind<F, R1, O1, E1, B>) => (a: A) => Kind<F, R1 & R2, O2 | O1, E2 | E1, C>;
-    <A_1, R1_1, O1_1, E1_1, B_1, R2_1, O2_1, E2_1, C_1>(afb: (a: A_1) => Kind<F, R1_1, O1_1, E1_1, B_1>, bfc: (b: B_1) => Kind<F, R2_1, O2_1, E2_1, C_1>): (a: A_1) => Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, C_1>;
+    <A, R1_1, O1_1, E1_1, B, R2_1, O2_1, E2_1, C_1>(afb: (a: A) => Kind<F, R1_1, O1_1, E1_1, B>, bfc: (b: B) => Kind<F, R2_1, O2_1, E2_1, C_1>): (a: A) => Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, C_1>;
 };
 //# sourceMappingURL=FlatMap.d.ts.map

dist/dts/Foldable.d.ts

@@ -28,4 +28,4 @@ /**
 export declare const toArrayMap: <F extends TypeLambda>(F: Foldable<F>) => {
-    <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => B[];
-    <R_1, O_1, E_1, A_1, B_1>(self: Kind<F, R_1, O_1, E_1, A_1>, f: (a: A_1) => B_1): B_1[];
+    <A, B>(f: (a: A) => B): <R, O, E>(self: Kind<F, R, O, E, A>) => Array<B>;
+    <R, O_1, E_1, A, B_1>(self: Kind<F, R, O_1, E_1, A>, f: (a: A) => B_1): Array<B_1>;
 };
@@ -35,3 +35,3 @@ /**
  */
-export declare const toArray: <F extends TypeLambda>(F: Foldable<F>) => <R, O, E, A>(self: Kind<F, R, O, E, A>) => A[];
+export declare const toArray: <F extends TypeLambda>(F: Foldable<F>) => <R, O, E, A>(self: Kind<F, R, O, E, A>) => Array<A>;
 /**
@@ -42,3 +42,3 @@ * @since 1.0.0
     <A>(f: (a: A) => M): <R, O, E>(self: Kind<F, R, O, E, A>) => M;
-    <R_1, O_1, E_1, A_1>(self: Kind<F, R_1, O_1, E_1, A_1>, f: (a: A_1) => M): M;
+    <R, O_1, E_1, A>(self: Kind<F, R, O_1, E_1, A>, f: (a: A) => M): M;
 };
@@ -50,3 +50,3 @@ /**
     <B, A, R, O, E>(b: B, f: (b: B, a: A) => Kind<G, R, O, E, B>): <FR, FO, FE>(self: Kind<F, FR, FO, FE, A>) => Kind<G, R, O, E, B>;
-    <FR_1, FO_1, FE_1, A_1, B_1, R_1, O_1, E_1>(self: Kind<F, FR_1, FO_1, FE_1, A_1>, b: B_1, f: (b: B_1, a: A_1) => Kind<G, R_1, O_1, E_1, B_1>): Kind<G, R_1, O_1, E_1, B_1>;
+    <FR, FO_1, FE_1, A_1, B, R_1, O_1, E_1>(self: Kind<F, FR, FO_1, FE_1, A_1>, b: B, f: (b: B, a: A_1) => Kind<G, R_1, O_1, E_1, B>): Kind<G, R_1, O_1, E_1, B>;
 };
@@ -58,4 +58,4 @@ /**
     <A, R, O, E, B>(f: (a: A) => Kind<G, R, O, E, B>): <FR, FO, FE>(self: Kind<F, FR, FO, FE, A>) => Kind<G, R, O, E, B>;
-    <FR_1, FO_1, FE_1, A_1, R_1, O_1, E_1, B_1>(self: Kind<F, FR_1, FO_1, FE_1, A_1>, f: (a: A_1) => Kind<G, R_1, O_1, E_1, B_1>): Kind<G, R_1, O_1, E_1, B_1>;
+    <FR, FO_1, FE_1, A, R_1, O_1, E_1, B_1>(self: Kind<F, FR, FO_1, FE_1, A>, f: (a: A) => Kind<G, R_1, O_1, E_1, B_1>): Kind<G, R_1, O_1, E_1, B_1>;
 };
 //# sourceMappingURL=Foldable.d.ts.map

dist/dts/Invariant.d.ts

@@ -24,3 +24,3 @@ import type { Kind, TypeClass, TypeLambda } from "effect/HKT";
     <N extends string>(name: N): <R, O, E, A>(self: Kind<F, R, O, E, A>) => Kind<F, R, O, E, { [K in N]: A; }>;
-    <R_1, O_1, E_1, A_1, N_1 extends string>(self: Kind<F, R_1, O_1, E_1, A_1>, name: N_1): Kind<F, R_1, O_1, E_1, { [K_1 in N_1]: A_1; }>;
+    <R, O_1, E_1, A_1, N extends string>(self: Kind<F, R, O_1, E_1, A_1>, name: N): Kind<F, R, O_1, E_1, { [K in N]: A_1; }>;
 };
@@ -27,0 +27,0 @@ /**

dist/dts/Monoid.d.ts

@@ -61,3 +61,3 @@ /**
  */
-export declare const tuple: <T extends readonly Monoid<any>[]>(...elements: T) => Monoid<{ readonly [I in keyof T]: [T[I]] extends [Monoid<infer A>] ? A : never; }>;
+export declare const tuple: <T extends ReadonlyArray<Monoid<any>>>(...elements: T) => Monoid<{ readonly [I in keyof T]: [T[I]] extends [Monoid<infer A>] ? A : never; }>;
 /**
@@ -64,0 +64,0 @@ * Given a type `A`, this function creates and returns a `Semigroup` for `ReadonlyArray<A>`.

dist/dts/Product.d.ts

@@ -17,3 +17,3 @@ /**
  */
-export declare const tuple: <F extends TypeLambda>(F: Product<F>) => <T extends readonly Kind<F, any, any, any, any>[]>(...elements: T) => Kind<F, [T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never, T[number] extends never ? never : [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never, T[number] extends never ? never : [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never, { [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
+export declare const tuple: <F extends TypeLambda>(F: Product<F>) => <T extends ReadonlyArray<Kind<F, any, any, any, any>>>(...elements: T) => Kind<F, ([T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never), (T[number] extends never ? never : [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never), (T[number] extends never ? never : [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never), { [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
 /**
@@ -24,3 +24,3 @@ * @since 1.0.0
     readonly [x: string]: Kind<F, any, any, any, any>;
-}>(fields: R) => Kind<F, [R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never, R[keyof R] extends never ? never : [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never, R[keyof R] extends never ? never : [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never, { [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
+}>(fields: R) => Kind<F, ([R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never), (R[keyof R] extends never ? never : [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never), (R[keyof R] extends never ? never : [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never), { [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
 //# sourceMappingURL=Product.d.ts.map

dist/dts/SemiApplicative.d.ts

@@ -29,3 +29,3 @@ import type { Kind, TypeLambda } from "effect/HKT";
     <R2, O2, E2, B, A, C>(that: Kind<F, R2, O2, E2, B>, f: (a: A, b: B) => C): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, C>;
-    <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, B_1, C_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>, f: (a: A_1, b: B_1) => C_1): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, C_1>;
+    <R1, O1_1, E1_1, A_1, R2, O2_1, E2_1, B_1, C_1>(self: Kind<F, R1, O1_1, E1_1, A_1>, that: Kind<F, R2, O2_1, E2_1, B_1>, f: (a: A_1, b: B_1) => C_1): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, C_1>;
 };
@@ -37,3 +37,3 @@ /**
     <R2, O2, E2, A>(that: Kind<F, R2, O2, E2, A>): <R1, O1, E1, B>(self: Kind<F, R1, O1, E1, (a: A) => B>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, B>;
-    <R1_1, O1_1, E1_1, A_1, B_1, R2_1, O2_1, E2_1>(self: Kind<F, R1_1, O1_1, E1_1, (a: A_1) => B_1>, that: Kind<F, R2_1, O2_1, E2_1, A_1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, B_1>;
+    <R1, O1_1, E1_1, A_1, B_1, R2, O2_1, E2_1>(self: Kind<F, R1, O1_1, E1_1, (a: A_1) => B_1>, that: Kind<F, R2, O2_1, E2_1, A_1>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, B_1>;
 };
@@ -45,3 +45,3 @@ /**
     <R2, O2, E2, _>(that: Kind<F, R2, O2, E2, _>): <R1, O1, E1, A>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, A>;
-    <R1_1, O1_1, E1_1, A_1, R2_1, O2_1, E2_1, __1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, __1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, A_1>;
+    <R1, O1_1, E1_1, A_1, R2, O2_1, E2_1, __1>(self: Kind<F, R1, O1_1, E1_1, A_1>, that: Kind<F, R2, O2_1, E2_1, __1>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, A_1>;
 };
@@ -53,3 +53,3 @@ /**
     <R2, O2, E2, B>(that: Kind<F, R2, O2, E2, B>): <R1, O1, E1, _>(self: Kind<F, R1, O1, E1, _>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, B>;
-    <R1_1, O1_1, E1_1, __1, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, __1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, B_1>;
+    <R1, O1_1, E1_1, __1, R2, O2_1, E2_1, B_1>(self: Kind<F, R1, O1_1, E1_1, __1>, that: Kind<F, R2, O2_1, E2_1, B_1>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, B_1>;
 };
@@ -66,4 +66,4 @@ /**
     <R2, O2, E2>(that: Kind<F, R2, O2, E2, B>): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, C>;
-    <R1_1, O1_1, E1_1, R2_1, O2_1, E2_1>(self: Kind<F, R1_1, O1_1, E1_1, A>, that: Kind<F, R2_1, O2_1, E2_1, B>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, C>;
+    <R1, O1_1, E1_1, R2, O2_1, E2_1>(self: Kind<F, R1, O1_1, E1_1, A>, that: Kind<F, R2, O2_1, E2_1, B>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, C>;
 };
 //# sourceMappingURL=SemiApplicative.d.ts.map

dist/dts/SemiProduct.d.ts

@@ -31,3 +31,3 @@ import type { Kind, TypeLambda } from "effect/HKT";
  */
-export declare const productManyComposition: <F extends TypeLambda, G extends TypeLambda>(F: SemiApplicative<F>, G: SemiProduct<G>) => <FR, FO, FE, GR, GO, GE, A>(self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>, collection: Iterable<Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>>) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, [A, ...A[]]>>;
+export declare const productManyComposition: <F extends TypeLambda, G extends TypeLambda>(F: SemiApplicative<F>, G: SemiProduct<G>) => <FR, FO, FE, GR, GO, GE, A>(self: Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>, collection: Iterable<Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, A>>>) => Kind<F, FR, FO, FE, Kind<G, GR, GO, GE, [A, ...Array<A>]>>;
 /**
@@ -38,4 +38,4 @@ * @category do notation
 export declare const andThenBind: <F extends TypeLambda>(F: SemiProduct<F>) => {
-    <N extends string, A extends object, R2, O2, E2, B>(name: Exclude<N, keyof A>, that: Kind<F, R2, O2, E2, B>): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, { [K in N | keyof A]: K extends keyof A ? A[K] : B; }>;
-    <R1_1, O1_1, E1_1, A_1 extends object, N_1 extends string, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, name: Exclude<N_1, keyof A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, { [K_1 in N_1 | keyof A_1]: K_1 extends keyof A_1 ? A_1[K_1] : B_1; }>;
+    <N extends string, A extends object, R2, O2, E2, B>(name: Exclude<N, keyof A>, that: Kind<F, R2, O2, E2, B>): <R1, O1, E1>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O1 | O2, E1 | E2, { [K in keyof A | N]: K extends keyof A ? A[K] : B; }>;
+    <R1, O1_1, E1_1, A_1 extends object, N extends string, R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1, O1_1, E1_1, A_1>, name: Exclude<N, keyof A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, { [K in keyof A_1 | N]: K extends keyof A_1 ? A_1[K] : B_1; }>;
 };
@@ -48,4 +48,4 @@ /**
 export declare const appendElement: <F extends TypeLambda>(F: SemiProduct<F>) => {
-    <R2, O2, E2, B>(that: Kind<F, R2, O2, E2, B>): <R1, O1, E1, A extends readonly any[]>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, [...A, B]>;
-    <R1_1, O1_1, E1_1, A_1 extends readonly any[], R2_1, O2_1, E2_1, B_1>(self: Kind<F, R1_1, O1_1, E1_1, A_1>, that: Kind<F, R2_1, O2_1, E2_1, B_1>): Kind<F, R1_1 & R2_1, O1_1 | O2_1, E1_1 | E2_1, [...A_1, B_1]>;
+    <R2, O2, E2, B>(that: Kind<F, R2, O2, E2, B>): <R1, O1, E1, A extends ReadonlyArray<any>>(self: Kind<F, R1, O1, E1, A>) => Kind<F, R1 & R2, O2 | O1, E2 | E1, [...A, B]>;
+    <R1, O1_1, E1_1, A_1 extends ReadonlyArray<any>, R2, O2_1, E2_1, B_1>(self: Kind<F, R1, O1_1, E1_1, A_1>, that: Kind<F, R2, O2_1, E2_1, B_1>): Kind<F, R1 & R2, O1_1 | O2_1, E1_1 | E2_1, [...A_1, B_1]>;
 };
@@ -55,3 +55,3 @@ /**
  */
-export declare const nonEmptyTuple: <F extends TypeLambda>(F: SemiProduct<F>) => <T extends readonly [Kind<F, any, any, any, any>, ...Kind<F, any, any, any, any>[]]>(...elements: T) => Kind<F, [T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never, [T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never, [T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never, { [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
+export declare const nonEmptyTuple: <F extends TypeLambda>(F: SemiProduct<F>) => <T extends readonly [Kind<F, any, any, any, any>, ...Array<Kind<F, any, any, any, any>>]>(...elements: T) => Kind<F, ([T[number]] extends [Kind<F, infer R, any, any, any>] ? R : never), ([T[number]] extends [Kind<F, any, infer O, any, any>] ? O : never), ([T[number]] extends [Kind<F, any, any, infer E, any>] ? E : never), { [I in keyof T]: [T[I]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
 type EnforceNonEmptyRecord<R> = keyof R extends never ? never : R;
@@ -65,4 +65,4 @@ /**
     readonly [x: string]: Kind<F, any, any, any, any>;
-}) => Kind<F, [R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never, [R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never, [R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never, { [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
+}) => Kind<F, ([R[keyof R]] extends [Kind<F, infer R_1, any, any, any>] ? R_1 : never), ([R[keyof R]] extends [Kind<F, any, infer O, any, any>] ? O : never), ([R[keyof R]] extends [Kind<F, any, any, infer E, any>] ? E : never), { [K in keyof R]: [R[K]] extends [Kind<F, any, any, any, infer A>] ? A : never; }>;
 export {};
 //# sourceMappingURL=SemiProduct.d.ts.map

dist/dts/Traversable.d.ts

@@ -35,4 +35,4 @@ import type { Kind, TypeClass, TypeLambda } from "effect/HKT";
     <A, R, O, E, B>(f: (a: A) => Kind<F, R, O, E, B>): <TR, TO, TE>(self: Kind<T, TR, TO, TE, A>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, A>>;
-    <TR_1, TO_1, TE_1, A_1, R_1, O_1, E_1, B_1>(self: Kind<T, TR_1, TO_1, TE_1, A_1>, f: (a: A_1) => Kind<F, R_1, O_1, E_1, B_1>): Kind<F, R_1, O_1, E_1, Kind<T, TR_1, TO_1, TE_1, A_1>>;
+    <TR, TO_1, TE_1, A, R_1, O_1, E_1, B_1>(self: Kind<T, TR, TO_1, TE_1, A>, f: (a: A) => Kind<F, R_1, O_1, E_1, B_1>): Kind<F, R_1, O_1, E_1, Kind<T, TR, TO_1, TE_1, A>>;
 };
 //# sourceMappingURL=Traversable.d.ts.map

dist/dts/TraversableFilterable.d.ts

@@ -11,3 +11,2 @@ /**
 import type { Covariant } from "./Covariant.js";
-import * as filterable from "./Filterable.js";
 import type { Filterable } from "./Filterable.js";
@@ -34,3 +33,3 @@ import type { Traversable } from "./Traversable.js";
  */
-export declare const traversePartitionMap: <T extends TypeLambda>(T: Traversable<T> & Covariant<T> & filterable.Filterable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, A, R, O, E, B, C>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Either<C, B>>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
+export declare const traversePartitionMap: <T extends TypeLambda>(T: Traversable<T> & Covariant<T> & Filterable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, A, R, O, E, B, C>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Either<C, B>>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, C>]>;
 /**
@@ -41,3 +40,3 @@ * Returns a default binary `traverseFilterMap` implementation.
  */
-export declare const traverseFilterMap: <T extends TypeLambda>(T: Traversable<T> & filterable.Filterable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, A, R, O, E, B>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Option<B>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>;
+export declare const traverseFilterMap: <T extends TypeLambda>(T: Traversable<T> & Filterable<T>) => <F extends TypeLambda>(F: Applicative<F>) => <TR, TO, TE, A, R, O, E, B>(self: Kind<T, TR, TO, TE, A>, f: (a: A) => Kind<F, R, O, E, Option<B>>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>;
 /**
@@ -48,3 +47,3 @@ * @since 1.0.0
     <B extends A, R, O, E, A = B>(predicate: (a: A) => Kind<F, R, O, E, boolean>): <TR, TO, TE>(self: Kind<T, TR, TO, TE, B>) => Kind<F, R, O, E, Kind<T, TR, TO, TE, B>>;
-    <TR_1, TO_1, TE_1, B_1 extends A_1, R_1, O_1, E_1, A_1 = B_1>(self: Kind<T, TR_1, TO_1, TE_1, B_1>, predicate: (a: A_1) => Kind<F, R_1, O_1, E_1, boolean>): Kind<F, R_1, O_1, E_1, Kind<T, TR_1, TO_1, TE_1, B_1>>;
+    <TR, TO_1, TE_1, B extends A_1, R_1, O_1, E_1, A_1 = B>(self: Kind<T, TR, TO_1, TE_1, B>, predicate: (a: A_1) => Kind<F, R_1, O_1, E_1, boolean>): Kind<F, R_1, O_1, E_1, Kind<T, TR, TO_1, TE_1, B>>;
 };
@@ -56,4 +55,4 @@ /**
     <B extends A, R, O, E, A = B>(predicate: (a: A) => Kind<F, R, O, E, boolean>): <TR, TO, TE>(self: Kind<T, TR, TO, TE, B>) => Kind<F, R, O, E, [Kind<T, TR, TO, TE, B>, Kind<T, TR, TO, TE, B>]>;
-    <TR_1, TO_1, TE_1, B_1 extends A_1, R_1, O_1, E_1, A_1 = B_1>(self: Kind<T, TR_1, TO_1, TE_1, B_1>, predicate: (a: A_1) => Kind<F, R_1, O_1, E_1, boolean>): Kind<F, R_1, O_1, E_1, [Kind<T, TR_1, TO_1, TE_1, B_1>, Kind<T, TR_1, TO_1, TE_1, B_1>]>;
+    <TR, TO_1, TE_1, B extends A_1, R_1, O_1, E_1, A_1 = B>(self: Kind<T, TR, TO_1, TE_1, B>, predicate: (a: A_1) => Kind<F, R_1, O_1, E_1, boolean>): Kind<F, R_1, O_1, E_1, [Kind<T, TR, TO_1, TE_1, B>, Kind<T, TR, TO_1, TE_1, B>]>;
 };
 //# sourceMappingURL=TraversableFilterable.d.ts.map

package.json

 {
   "name": "@effect/typeclass",
-  "version": "0.24.34",
+  "version": "0.24.35",
   "description": "A collection of reusable typeclasses for the Effect ecosystem",
@@ -13,3 +13,3 @@ "license": "MIT",
   "peerDependencies": {
-    "effect": "^3.4.2"
+    "effect": "^3.4.3"
   },
@@ -16,0 +16,0 @@ "publishConfig": {

No alert changes

Improved metrics

Total package byte prevSize

585853

increased by6.09%

Worsened metrics

Lines of code

11111

decreased by-0.04%

No dependency changes