@effect/data
Advanced tools
@effect/data - npm Package Compare versions
Comparing version 0.12.8 to 0.12.9
| { | ||
| "name": "@effect/data", | ||
| "version": "0.12.8", | ||
| "version": "0.12.9", | ||
| "license": "MIT", | ||
@@ -5,0 +5,0 @@ "repository": { |
@@ -126,3 +126,3 @@ /** | ||
| <K extends string, A, B>(f: (key: K, a: A) => B): (self: Record<K, A>) => Array<B>; | ||
| <K extends string, A, B>(self: Record<K, A>, f: (key: string, a: A) => B): Array<B>; | ||
| <K extends string, A, B>(self: Record<K, A>, f: (key: K, a: A) => B): Array<B>; | ||
| }; | ||
@@ -345,4 +345,4 @@ /** | ||
| export declare const filterMap: { | ||
| <A, B>(f: (a: A, key: string) => Option<B>): (self: ReadonlyRecord<A>) => Record<string, B>; | ||
| <A, B>(self: ReadonlyRecord<A>, f: (a: A, key: string) => Option<B>): Record<string, B>; | ||
| <K extends string, A, B>(f: (a: A, key: K) => Option<B>): (self: Record<K, A>) => Record<string, B>; | ||
| <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => Option<B>): Record<string, B>; | ||
| }; | ||
@@ -365,6 +365,6 @@ /** | ||
| export declare const filter: { | ||
| <C extends A, B extends A, A = C>(refinement: (a: A, key: string) => a is B): (self: ReadonlyRecord<C>) => Record<string, B>; | ||
| <B extends A, A = B>(predicate: (a: A, key: string) => boolean): (self: ReadonlyRecord<B>) => Record<string, B>; | ||
| <C extends A, B extends A, A = C>(self: ReadonlyRecord<C>, refinement: (a: A, key: string) => a is B): Record<string, B>; | ||
| <B extends A, A = B>(self: ReadonlyRecord<B>, predicate: (a: A, key: string) => boolean): Record<string, B>; | ||
| <K extends string, C extends A, B extends A, A = C>(refinement: (a: A, key: K) => a is B): (self: Record<K, C>) => Record<string, B>; | ||
| <K extends string, B extends A, A = B>(predicate: (a: A, key: K) => boolean): (self: Record<K, B>) => Record<string, B>; | ||
| <K extends string, C extends A, B extends A, A = C>(self: Record<K, C>, refinement: (a: A, key: K) => a is B): Record<string, B>; | ||
| <K extends string, B extends A, A = B>(self: Record<K, B>, predicate: (a: A, key: K) => boolean): Record<string, B>; | ||
| }; | ||
@@ -407,4 +407,4 @@ /** | ||
| export declare const partitionMap: { | ||
| <A, B, C>(f: (a: A, key: string) => Either<B, C>): (self: ReadonlyRecord<A>) => [Record<string, B>, Record<string, C>]; | ||
| <A, B, C>(self: ReadonlyRecord<A>, f: (a: A, key: string) => Either<B, C>): [Record<string, B>, Record<string, C>]; | ||
| <K extends string, A, B, C>(f: (a: A, key: K) => Either<B, C>): (self: Record<K, A>) => [Record<string, B>, Record<string, C>]; | ||
| <K extends string, A, B, C>(self: Record<K, A>, f: (a: A, key: K) => Either<B, C>): [Record<string, B>, Record<string, C>]; | ||
| }; | ||
@@ -448,6 +448,6 @@ /** | ||
| export declare const partition: { | ||
| <C extends A, B extends A, A = C>(refinement: (a: A, key: string) => a is B): (self: ReadonlyRecord<C>) => [Record<string, C>, Record<string, B>]; | ||
| <B extends A, A = B>(predicate: (a: A, key: string) => boolean): (self: ReadonlyRecord<B>) => [Record<string, B>, Record<string, B>]; | ||
| <C extends A, B extends A, A = C>(self: ReadonlyRecord<C>, refinement: (a: A, key: string) => a is B): [Record<string, C>, Record<string, B>]; | ||
| <B extends A, A = B>(self: ReadonlyRecord<B>, predicate: (a: A, key: string) => boolean): [Record<string, B>, Record<string, B>]; | ||
| <K extends string, C extends A, B extends A, A = C>(refinement: (a: A, key: K) => a is B): (self: Record<K, C>) => [Record<string, C>, Record<string, B>]; | ||
| <K extends string, B extends A, A = B>(predicate: (a: A, key: K) => boolean): (self: Record<K, B>) => [Record<string, B>, Record<string, B>]; | ||
| <K extends string, C extends A, B extends A, A = C>(self: Record<K, C>, refinement: (a: A, key: K) => a is B): [Record<string, C>, Record<string, B>]; | ||
| <K extends string, B extends A, A = B>(self: Record<K, B>, predicate: (a: A, key: K) => boolean): [Record<string, B>, Record<string, B>]; | ||
| }; | ||
@@ -478,4 +478,4 @@ /** | ||
| export declare const traverse: <F extends TypeLambda>(F: applicative.Applicative<F>) => { | ||
| <A, R, O, E, B>(f: (a: A, key: string) => Kind<F, R, O, E, B>): (self: ReadonlyRecord<A>) => Kind<F, R, O, E, Record<string, B>>; | ||
| <A_1, R_1, O_1, E_1, B_1>(self: ReadonlyRecord<A_1>, f: (a: A_1, key: string) => Kind<F, R_1, O_1, E_1, B_1>): Kind<F, R_1, O_1, E_1, Record<string, B_1>>; | ||
| <K extends string, A, R, O, E, B>(f: (a: A, key: K) => Kind<F, R, O, E, B>): (self: Record<K, A>) => Kind<F, R, O, E, Record<string, B>>; | ||
| <K_1 extends string, A_1, R_1, O_1, E_1, B_1>(self: Record<K_1, A_1>, f: (a: A_1, key: K_1) => Kind<F, R_1, O_1, E_1, B_1>): Kind<F, R_1, O_1, E_1, Record<string, B_1>>; | ||
| }; | ||
@@ -482,0 +482,0 @@ /** |
@@ -168,3 +168,3 @@ /** | ||
| <K extends string, A, B>(f: (key: K, a: A) => B): (self: Record<K, A>) => Array<B> | ||
| <K extends string, A, B>(self: Record<K, A>, f: (key: string, a: A) => B): Array<B> | ||
| <K extends string, A, B>(self: Record<K, A>, f: (key: K, a: A) => B): Array<B> | ||
| } = dual( | ||
@@ -449,6 +449,6 @@ 2, | ||
| export const filterMap: { | ||
| <A, B>(f: (a: A, key: string) => Option<B>): (self: ReadonlyRecord<A>) => Record<string, B> | ||
| <A, B>(self: ReadonlyRecord<A>, f: (a: A, key: string) => Option<B>): Record<string, B> | ||
| <K extends string, A, B>(f: (a: A, key: K) => Option<B>): (self: Record<K, A>) => Record<string, B> | ||
| <K extends string, A, B>(self: Record<K, A>, f: (a: A, key: K) => Option<B>): Record<string, B> | ||
| } = dual(2, <A, B>( | ||
| self: ReadonlyRecord<A>, | ||
| self: Record<string, A>, | ||
| f: (a: A, key: string) => Option<B> | ||
@@ -482,15 +482,15 @@ ): Record<string, B> => { | ||
| export const filter: { | ||
| <C extends A, B extends A, A = C>( | ||
| refinement: (a: A, key: string) => a is B | ||
| ): (self: ReadonlyRecord<C>) => Record<string, B> | ||
| <B extends A, A = B>( | ||
| predicate: (a: A, key: string) => boolean | ||
| ): (self: ReadonlyRecord<B>) => Record<string, B> | ||
| <C extends A, B extends A, A = C>( | ||
| self: ReadonlyRecord<C>, | ||
| refinement: (a: A, key: string) => a is B | ||
| <K extends string, C extends A, B extends A, A = C>( | ||
| refinement: (a: A, key: K) => a is B | ||
| ): (self: Record<K, C>) => Record<string, B> | ||
| <K extends string, B extends A, A = B>( | ||
| predicate: (a: A, key: K) => boolean | ||
| ): (self: Record<K, B>) => Record<string, B> | ||
| <K extends string, C extends A, B extends A, A = C>( | ||
| self: Record<K, C>, | ||
| refinement: (a: A, key: K) => a is B | ||
| ): Record<string, B> | ||
| <B extends A, A = B>( | ||
| self: ReadonlyRecord<B>, | ||
| predicate: (a: A, key: string) => boolean | ||
| <K extends string, B extends A, A = B>( | ||
| self: Record<K, B>, | ||
| predicate: (a: A, key: K) => boolean | ||
| ): Record<string, B> | ||
@@ -500,3 +500,3 @@ } = dual( | ||
| <B extends A, A = B>( | ||
| self: ReadonlyRecord<B>, | ||
| self: Record<string, B>, | ||
| predicate: (a: A, key: string) => boolean | ||
@@ -553,8 +553,8 @@ ): Record<string, B> => { | ||
| export const partitionMap: { | ||
| <A, B, C>( | ||
| f: (a: A, key: string) => Either<B, C> | ||
| ): (self: ReadonlyRecord<A>) => [Record<string, B>, Record<string, C>] | ||
| <A, B, C>( | ||
| self: ReadonlyRecord<A>, | ||
| f: (a: A, key: string) => Either<B, C> | ||
| <K extends string, A, B, C>( | ||
| f: (a: A, key: K) => Either<B, C> | ||
| ): (self: Record<K, A>) => [Record<string, B>, Record<string, C>] | ||
| <K extends string, A, B, C>( | ||
| self: Record<K, A>, | ||
| f: (a: A, key: K) => Either<B, C> | ||
| ): [Record<string, B>, Record<string, C>] | ||
@@ -564,3 +564,3 @@ } = dual( | ||
| <A, B, C>( | ||
| self: ReadonlyRecord<A>, | ||
| self: Record<string, A>, | ||
| f: (a: A, key: string) => Either<B, C> | ||
@@ -622,15 +622,15 @@ ): [Record<string, B>, Record<string, C>] => { | ||
| export const partition: { | ||
| <C extends A, B extends A, A = C>(refinement: (a: A, key: string) => a is B): ( | ||
| self: ReadonlyRecord<C> | ||
| <K extends string, C extends A, B extends A, A = C>(refinement: (a: A, key: K) => a is B): ( | ||
| self: Record<K, C> | ||
| ) => [Record<string, C>, Record<string, B>] | ||
| <B extends A, A = B>( | ||
| predicate: (a: A, key: string) => boolean | ||
| ): (self: ReadonlyRecord<B>) => [Record<string, B>, Record<string, B>] | ||
| <C extends A, B extends A, A = C>( | ||
| self: ReadonlyRecord<C>, | ||
| refinement: (a: A, key: string) => a is B | ||
| <K extends string, B extends A, A = B>( | ||
| predicate: (a: A, key: K) => boolean | ||
| ): (self: Record<K, B>) => [Record<string, B>, Record<string, B>] | ||
| <K extends string, C extends A, B extends A, A = C>( | ||
| self: Record<K, C>, | ||
| refinement: (a: A, key: K) => a is B | ||
| ): [Record<string, C>, Record<string, B>] | ||
| <B extends A, A = B>( | ||
| self: ReadonlyRecord<B>, | ||
| predicate: (a: A, key: string) => boolean | ||
| <K extends string, B extends A, A = B>( | ||
| self: Record<K, B>, | ||
| predicate: (a: A, key: K) => boolean | ||
| ): [Record<string, B>, Record<string, B>] | ||
@@ -640,3 +640,3 @@ } = dual( | ||
| <B extends A, A = B>( | ||
| self: ReadonlyRecord<B>, | ||
| self: Record<string, B>, | ||
| predicate: (a: A, key: string) => boolean | ||
@@ -681,12 +681,12 @@ ): [Record<string, B>, Record<string, B>] => { | ||
| export const traverse = <F extends TypeLambda>(F: applicative.Applicative<F>): { | ||
| <A, R, O, E, B>( | ||
| f: (a: A, key: string) => Kind<F, R, O, E, B> | ||
| ): (self: ReadonlyRecord<A>) => Kind<F, R, O, E, Record<string, B>> | ||
| <A, R, O, E, B>( | ||
| self: ReadonlyRecord<A>, | ||
| f: (a: A, key: string) => Kind<F, R, O, E, B> | ||
| <K extends string, A, R, O, E, B>( | ||
| f: (a: A, key: K) => Kind<F, R, O, E, B> | ||
| ): (self: Record<K, A>) => Kind<F, R, O, E, Record<string, B>> | ||
| <K extends string, A, R, O, E, B>( | ||
| self: Record<K, A>, | ||
| f: (a: A, key: K) => Kind<F, R, O, E, B> | ||
| ): Kind<F, R, O, E, Record<string, B>> | ||
| } => | ||
| dual(2, <A, R, O, E, B>( | ||
| self: ReadonlyRecord<A>, | ||
| self: Record<string, A>, | ||
| f: (a: A, key: string) => Kind<F, R, O, E, B> | ||
@@ -693,0 +693,0 @@ ): Kind<F, R, O, E, Record<string, B>> => |
Sorry, the diff of this file is not supported yet
New alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Fixed alerts
License Policy Violation
LicenseThis package is not allowed per your license policy. Review the package's license to ensure compliance.
Found 1 instance in 1 package
Improved metrics
- Total package byte prevSize
- increased by0.02%
3732373
No dependency changes