Socket
Socket
Sign inDemoInstall

@effect/data

Package Overview
Dependencies
Maintainers
3
Versions
79
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@effect/data - npm Package Compare versions

Comparing version 0.0.1 to 0.1.0

8

Brand.js

@@ -84,3 +84,5 @@ "use strict";

[RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
of: args => Either.getOrThrow(_Function.identity)(either(args)),
of: args => Either.match(e => {
throw e;
}, _Function.identity)(either(args)),
option: args => Option.fromEither(either(args)),

@@ -115,3 +117,5 @@ either,

[RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
of: args => Either.getOrThrow(_Function.identity)(either(args)),
of: args => Either.match(e => {
throw e;
}, _Function.identity)(either(args)),
option: args => Option.fromEither(either(args)),

@@ -118,0 +122,0 @@ either,

165

Chunk.d.ts

@@ -0,1 +1,4 @@

/**
* @since 1.0.0
*/
import * as Equal from "@effect/data/Equal";

@@ -116,4 +119,4 @@ import type { NonEmptyIterable } from "@effect/data/NonEmpty";

export declare const get: {
(index: number): <A>(self: Chunk<A>) => Option<A>;
<A>(self: Chunk<A>, index: number): Option<A>;
(index: number): <A>(self: Chunk<A>) => Option<A>;
};

@@ -134,4 +137,4 @@ /**

export declare const unsafeGet: {
(index: number): <A>(self: Chunk<A>) => A;
<A>(self: Chunk<A>, index: number): A;
(index: number): <A>(self: Chunk<A>) => A;
};

@@ -145,4 +148,4 @@ /**

export declare const append: {
<A2>(a: A2): <A>(self: Chunk<A>) => Chunk<A2 | A>;
<A, A2>(self: Chunk<A>, a: A2): Chunk<A | A2>;
<A2>(a: A2): <A>(self: Chunk<A>) => Chunk<A2 | A>;
};

@@ -156,4 +159,4 @@ /**

export declare const prepend: {
<B>(elem: B): <A>(self: Chunk<A>) => Chunk<B | A>;
<A, B>(self: Chunk<A>, elem: B): Chunk<A | B>;
<B>(elem: B): <A>(self: Chunk<A>) => Chunk<B | A>;
};

@@ -167,4 +170,4 @@ /**

export declare const take: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, n: number): Chunk<A>;
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
};

@@ -178,4 +181,4 @@ /**

export declare const drop: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, n: number): Chunk<A>;
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
};

@@ -189,4 +192,4 @@ /**

export declare const dropRight: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, n: number): Chunk<A>;
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
};

@@ -200,4 +203,4 @@ /**

export declare const dropWhile: {
<A>(f: (a: A) => boolean): (self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, f: (a: A) => boolean): Chunk<A>;
<A>(f: (a: A) => boolean): (self: Chunk<A>) => Chunk<A>;
};

@@ -209,6 +212,6 @@ /**

export declare const prependAllNonEmpty: {
<B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>;
<B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<B | A>;
<A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>;
<A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>;
<B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<A | B>;
<B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<A | B>;
};

@@ -222,4 +225,4 @@ /**

export declare const concat: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<B | A>;
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<B | A>;
};

@@ -233,4 +236,4 @@ /**

export declare const correspondsTo: {
<A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean): (self: Chunk<A>) => boolean;
<A, B>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => boolean): boolean;
<A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean): (self: Chunk<A>) => boolean;
};

@@ -244,4 +247,4 @@ /**

export declare const filterMap: {
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>;
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>): Chunk<B>;
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>;
};

@@ -255,6 +258,6 @@ /**

export declare const filter: {
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>;
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>;
<C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): Chunk<B>;
<B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): Chunk<B>;
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>;
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>;
};

@@ -268,4 +271,4 @@ /**

export declare const filterMapWithIndex: {
<A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Chunk<B>;
<A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Chunk<B>;
<A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Chunk<B>;
};

@@ -279,4 +282,4 @@ /**

export declare const filterMapWhile: {
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>;
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>): Chunk<B>;
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>;
};

@@ -290,4 +293,4 @@ /**

export declare const elem: {
<B>(b: B): <A>(self: Chunk<A>) => boolean;
<A, B>(self: Chunk<A>, b: B): boolean;
<B>(b: B): <A>(self: Chunk<A>) => boolean;
};

@@ -315,4 +318,4 @@ /**

export declare const some: {
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean;
<A>(self: Chunk<A>, f: Predicate<A>): boolean;
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean;
};

@@ -326,4 +329,4 @@ /**

export declare const every: {
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean;
<A>(self: Chunk<A>, f: Predicate<A>): boolean;
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean;
};

@@ -337,7 +340,6 @@ /**

export declare const findFirst: {
<A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>;
<A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<A>;
<A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>;
<A_1>(self: Chunk<A_1>, predicate: Predicate<A_1>): Option<A_1>;
} & {
<A_2, B_1 extends A_2>(refinement: Refinement<A_2, B_1>): (self: Chunk<A_2>) => Option<B_1>;
<A_3>(predicate: Predicate<A_3>): (self: Chunk<A_3>) => Option<A_3>;
<A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>;
};

@@ -350,3 +352,6 @@ /**

*/
export declare const findFirstIndex: (<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => Option<number>);
export declare const findFirstIndex: {
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<number>;
<A>(self: Chunk<A>, f: Predicate<A>): Option<number>;
};
/**

@@ -358,3 +363,6 @@ * Find the first index for which a predicate holds

*/
export declare const findLastIndex: (<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>) & (<A_1>(f: Predicate<A_1>) => (self: Chunk<A_1>) => Option<number>);
export declare const findLastIndex: {
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<number>;
<A>(self: Chunk<A>, f: Predicate<A>): Option<number>;
};
/**

@@ -367,7 +375,6 @@ * Find the last element which satisfies a predicate function

export declare const findLast: {
<A, B extends A>(f: Refinement<A, B>): (self: Chunk<A>) => Option<B>;
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<A>;
<A, B extends A>(self: Chunk<A>, f: Refinement<A, B>): Option<B>;
<A_1>(self: Chunk<A_1>, f: Predicate<A_1>): Option<A_1>;
} & {
<A_2, B_1 extends A_2>(f: Refinement<A_2, B_1>): (self: Chunk<A_2>) => Option<B_1>;
<A_3>(f: Predicate<A_3>): (self: Chunk<A_3>) => Option<A_3>;
<A>(self: Chunk<A>, f: Predicate<A>): Option<A>;
};

@@ -380,3 +387,6 @@ /**

*/
export declare const flatMap: (<A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>) => Chunk<B>) & (<A_1, B_1>(f: (a: A_1) => Chunk<B_1>) => (self: Chunk<A_1>) => Chunk<B_1>);
export declare const flatMap: {
<A, B>(f: (a: A) => Chunk<B>): (self: Chunk<A>) => Chunk<B>;
<A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>): Chunk<B>;
};
/**

@@ -395,3 +405,6 @@ * Flattens a chunk of chunks into a single chunk by concatenating all chunks.

*/
export declare const forEach: (<A>(self: Chunk<A>, f: (a: A) => void) => void) & (<A_1>(f: (a: A_1) => void) => (self: Chunk<A_1>) => void);
export declare const forEach: {
<A>(f: (a: A) => void): (self: Chunk<A>) => void;
<A>(self: Chunk<A>, f: (a: A) => void): void;
};
/**

@@ -403,3 +416,6 @@ * Groups elements in chunks of up to `n` elements.

*/
export declare const chunksOf: (<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>) & ((n: number) => <A_1>(self: Chunk<A_1>) => Chunk<Chunk<A_1>>);
export declare const chunksOf: {
(n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
<A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
};
/**

@@ -420,3 +436,6 @@ * Returns the first element of this chunk if it exists.

*/
export declare const intersection: (<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A & B>) & (<A_1>(that: Chunk<A_1>) => <B_1>(self: Chunk<B_1>) => Chunk<A_1 & B_1>);
export declare const intersection: {
<A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A & B>;
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A & B>;
};
/**

@@ -442,3 +461,6 @@ * Determines if the chunk is empty.

*/
export declare const reduce: (<A, B>(self: Chunk<A>, b: B, f: (s: B, a: A) => B) => B) & (<A_1, B_1>(b: B_1, f: (s: B_1, a: A_1) => B_1) => (self: Chunk<A_1>) => B_1);
export declare const reduce: {
<A, B>(b: B, f: (s: B, a: A) => B): (self: Chunk<A>) => B;
<A, B>(self: Chunk<A>, b: B, f: (s: B, a: A) => B): B;
};
/**

@@ -450,3 +472,6 @@ * Folds over the elements in this chunk from the left.

*/
export declare const reduceWithIndex: (<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B) & (<B_1, A_1>(b: B_1, f: (b: B_1, a: A_1, i: number) => B_1) => (self: Chunk<A_1>) => B_1);
export declare const reduceWithIndex: {
<B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B;
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B;
};
/**

@@ -458,3 +483,6 @@ * Folds over the elements in this chunk from the right.

*/
export declare const reduceRight: (<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A) => B) => B) & (<B_1, A_1>(b: B_1, f: (b: B_1, a: A_1) => B_1) => (self: Chunk<A_1>) => B_1);
export declare const reduceRight: {
<B, A>(b: B, f: (b: B, a: A) => B): (self: Chunk<A>) => B;
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A) => B): B;
};
/**

@@ -466,3 +494,6 @@ * Folds over the elements in this chunk from the right.

*/
export declare const reduceRightWithIndex: (<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B) & (<B_1, A_1>(b: B_1, f: (b: B_1, a: A_1, i: number) => B_1) => (self: Chunk<A_1>) => B_1);
export declare const reduceRightWithIndex: {
<B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B;
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B;
};
/**

@@ -475,4 +506,4 @@ * Joins the elements together with "sep" in the middle.

export declare const join: {
(sep: string): (self: Chunk<string>) => string;
(self: Chunk<string>, sep: string): string;
(sep: string): (self: Chunk<string>) => string;
};

@@ -509,4 +540,4 @@ /**

export declare const makeBy: {
<A>(f: (i: number) => A): (n: number) => NonEmptyChunk<A>;
<A>(n: number, f: (i: number) => A): NonEmptyChunk<A>;
<A>(f: (i: number) => A): (n: number) => NonEmptyChunk<A>;
};

@@ -520,4 +551,4 @@ /**

export declare const map: {
<A, B>(f: (a: A) => B): (self: Chunk<A>) => Chunk<B>;
<A, B>(self: Chunk<A>, f: (a: A) => B): Chunk<B>;
<A, B>(f: (a: A) => B): (self: Chunk<A>) => Chunk<B>;
};

@@ -531,4 +562,4 @@ /**

export declare const mapWithIndex: {
<A, B>(f: (a: A, i: number) => B): (self: Chunk<A>) => Chunk<B>;
<A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B>;
<A, B>(f: (a: A, i: number) => B): (self: Chunk<A>) => Chunk<B>;
};

@@ -542,4 +573,4 @@ /**

export declare const mapAccum: {
<S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk<A>) => readonly [S, Chunk<B>];
<S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]): readonly [S, Chunk<B>];
<S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk<A>) => readonly [S, Chunk<B>];
};

@@ -553,6 +584,6 @@ /**

export declare const partitionWithIndex: {
<C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (self: Chunk<C>) => readonly [Chunk<C>, Chunk<B>];
<B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>];
<C extends A, B extends A, A = C>(self: Chunk<C>, refinement: (a: A, i: number) => a is B): readonly [Chunk<C>, Chunk<B>];
<B extends A, A = B>(self: Chunk<B>, predicate: (a: A, i: number) => boolean): readonly [Chunk<B>, Chunk<B>];
<C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (self: Chunk<C>) => readonly [Chunk<C>, Chunk<B>];
<B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>];
};

@@ -566,6 +597,6 @@ /**

export declare const partition: {
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => readonly [Chunk<C>, Chunk<B>];
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>];
<C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): readonly [Chunk<C>, Chunk<B>];
<B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): readonly [Chunk<B>, Chunk<B>];
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => readonly [Chunk<C>, Chunk<B>];
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>];
};

@@ -579,4 +610,4 @@ /**

export declare const partitionMap: {
<A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => readonly [Chunk<B>, Chunk<C>];
<A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): readonly [Chunk<B>, Chunk<C>];
<A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => readonly [Chunk<B>, Chunk<C>];
};

@@ -618,4 +649,4 @@ /**

export declare const sort: {
<B>(O: Order<B>): <A extends B>(self: Chunk<A>) => Chunk<A>;
<A extends B, B>(self: Chunk<A>, O: Order<B>): Chunk<A>;
<B>(O: Order<B>): <A extends B>(self: Chunk<A>) => Chunk<A>;
};

@@ -629,4 +660,4 @@ /**

export declare const splitAt: {
(n: number): <A>(self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>];
<A>(self: Chunk<A>, n: number): readonly [Chunk<A>, Chunk<A>];
(n: number): <A>(self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>];
};

@@ -640,4 +671,4 @@ /**

export declare const split: {
(n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
<A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>;
(n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>;
};

@@ -651,4 +682,4 @@ /**

export declare const splitWhere: {
<A>(f: Predicate<A>): (self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>];
<A>(self: Chunk<A>, f: Predicate<A>): readonly [Chunk<A>, Chunk<A>];
<A>(f: Predicate<A>): (self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>];
};

@@ -669,4 +700,4 @@ /**

export declare const takeRight: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, n: number): Chunk<A>;
(n: number): <A>(self: Chunk<A>) => Chunk<A>;
};

@@ -680,4 +711,4 @@ /**

export declare const takeWhile: {
<A>(f: Predicate<A>): (self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, f: Predicate<A>): Chunk<A>;
<A>(f: Predicate<A>): (self: Chunk<A>) => Chunk<A>;
};

@@ -698,4 +729,4 @@ /**

export declare const union: {
<A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>;
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>;
<A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>;
};

@@ -739,4 +770,4 @@ /**

export declare const zip: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>;
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<readonly [A, B]>;
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>;
};

@@ -750,4 +781,4 @@ /**

export declare const zipWith: {
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>;
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C): Chunk<C>;
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>;
};

@@ -764,4 +795,4 @@ /**

export declare const zipAll: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [Option<A>, Option<B>]>;
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<readonly [Option<A>, Option<B>]>;
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [Option<A>, Option<B>]>;
};

@@ -779,4 +810,4 @@ /**

export declare const zipAllWith: {
<A, B, C, D, E>(that: Chunk<B>, f: (a: A, b: B) => C, left: (a: A) => D, right: (b: B) => E): (self: Chunk<A>) => Chunk<C | D | E>;
<A, B, C, D, E>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C, left: (a: A) => D, right: (b: B) => E): Chunk<C | D | E>;
<A, B, C, D, E>(that: Chunk<B>, f: (a: A, b: B) => C, left: (a: A) => D, right: (b: B) => E): (self: Chunk<A>) => Chunk<C | D | E>;
};

@@ -790,4 +821,4 @@ /**

export declare const crossWith: {
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>;
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C): Chunk<C>;
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>;
};

@@ -801,4 +832,4 @@ /**

export declare const cross: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>;
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<readonly [A, B]>;
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>;
};

@@ -821,4 +852,4 @@ /**

export declare const zipWithIndexOffset: {
(offset: number): <A>(self: Chunk<A>) => Chunk<[A, number]>;
<A>(self: Chunk<A>, offset: number): Chunk<[A, number]>;
(offset: number): <A>(self: Chunk<A>) => Chunk<[A, number]>;
};

@@ -833,4 +864,4 @@ /**

export declare const remove: {
(i: number): <A>(self: Chunk<A>) => Chunk<A>;
<A>(self: Chunk<A>, i: number): Chunk<A>;
(i: number): <A>(self: Chunk<A>) => Chunk<A>;
};

@@ -845,4 +876,4 @@ /**

export declare const replace: {
<B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A>;
<A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A>;
<B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A>;
};

@@ -854,4 +885,4 @@ /**

export declare const replaceOption: {
<B>(i: number, b: B): <A>(self: Chunk<A>) => Option<Chunk<B | A>>;
<A, B>(self: Chunk<A>, i: number, b: B): Option<Chunk<B | A>>;
<B>(i: number, b: B): <A>(self: Chunk<A>) => Option<Chunk<B | A>>;
};

@@ -866,4 +897,4 @@ /**

export declare const modify: {
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B>;
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B>;
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B>;
};

@@ -875,4 +906,4 @@ /**

export declare const modifyOption: {
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Option<Chunk<A | B>>;
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>>;
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Option<Chunk<A | B>>;
};

@@ -879,0 +910,0 @@ /**

19

Chunk.js

@@ -7,6 +7,5 @@ "use strict";

exports.zipWithIndexOffset = exports.zipWithIndex = exports.zipWith = exports.zipAllWith = exports.zipAll = exports.zip = exports.unzip = exports.unsafeLast = exports.unsafeHead = exports.unsafeGet = exports.unsafeFromArray = exports.union = exports.unfold = exports.toReadonlyArray = exports.takeWhile = exports.takeRight = exports.take = exports.tailNonEmpty = exports.tail = exports.splitWhere = exports.splitAt = exports.split = exports.sort = exports.some = exports.size = exports.separate = exports.reverse = exports.replaceOption = exports.replace = exports.remove = exports.reduceWithIndex = exports.reduceRightWithIndex = exports.reduceRight = exports.reduce = exports.range = exports.prependAllNonEmpty = exports.prepend = exports.partitionWithIndex = exports.partitionMap = exports.partition = exports.of = exports.modifyOption = exports.modify = exports.mapWithIndex = exports.mapAccum = exports.map = exports.makeBy = exports.make = exports.last = exports.join = exports.isNonEmpty = exports.isEmpty = exports.isChunk = exports.intersection = exports.headNonEmpty = exports.head = exports.get = exports.fromIterable = exports.forEach = exports.flatten = exports.flatMap = exports.findLastIndex = exports.findLast = exports.findFirstIndex = exports.findFirst = exports.filterMapWithIndex = exports.filterMapWhile = exports.filterMap = exports.filter = exports.every = exports.empty = exports.elem = exports.dropWhile = exports.dropRight = exports.drop = exports.dedupeAdjacent = exports.dedupe = exports.crossWith = exports.cross = exports.correspondsTo = exports.concat = exports.compact = exports.chunksOf = exports.append = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var _Function = /*#__PURE__*/require("@fp-ts/core/Function");
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var O = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -484,3 +483,3 @@ var RA = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/ReadonlyArray"));

exports.filter = filter;
const filterMapWithIndex = /*#__PURE__*/Dual.dual(2, (self, f) => unsafeFromArray(RA.filterMapWithIndex(f)(self)));
const filterMapWithIndex = /*#__PURE__*/Dual.dual(2, (self, f) => unsafeFromArray(RA.filterMap(f)(self)));
/**

@@ -520,3 +519,3 @@ * Transforms all elements of the chunk for as long as the specified function returns some value

exports.elem = elem;
const compact = self => filterMap(self, _Function.identity);
const compact = self => filterMap(self, Dual.identity);
/**

@@ -612,3 +611,3 @@ * Deduplicates adjacent elements that are identical.

exports.flatMap = flatMap;
const flatten = /*#__PURE__*/flatMap(_Function.identity);
const flatten = /*#__PURE__*/flatMap(Dual.identity);
/**

@@ -693,3 +692,3 @@ * Iterate over the chunk applying `f`.

exports.reduce = reduce;
const reduceWithIndex = /*#__PURE__*/Dual.dual(3, (self, b, f) => RA.reduceWithIndex(b, f)(toReadonlyArray(self)));
const reduceWithIndex = /*#__PURE__*/Dual.dual(3, (self, b, f) => RA.reduce(b, f)(toReadonlyArray(self)));
/**

@@ -710,3 +709,3 @@ * Folds over the elements in this chunk from the right.

exports.reduceRight = reduceRight;
const reduceRightWithIndex = /*#__PURE__*/Dual.dual(3, (self, b, f) => RA.reduceRightWithIndex(b, f)(toReadonlyArray(self)));
const reduceRightWithIndex = /*#__PURE__*/Dual.dual(3, (self, b, f) => RA.reduceRight(b, f)(toReadonlyArray(self)));
/**

@@ -756,3 +755,3 @@ * Joins the elements together with "sep" in the middle.

exports.of = of;
const makeBy = /*#__PURE__*/Dual.dual(2, (n, f) => make(...RA.makeBy(f)(n)));
const makeBy = /*#__PURE__*/Dual.dual(2, (n, f) => make(...RA.makeBy(n, f)));
/**

@@ -773,3 +772,3 @@ * Returns an effect whose success is mapped by the specified f function.

exports.map = map;
const mapWithIndex = /*#__PURE__*/Dual.dual(2, (self, f) => self.backing._tag === "ISingleton" ? of(f(self.backing.a, 0)) : unsafeFromArray(RA.mapWithIndex(f)(toReadonlyArray(self))));
const mapWithIndex = /*#__PURE__*/Dual.dual(2, (self, f) => self.backing._tag === "ISingleton" ? of(f(self.backing.a, 0)) : unsafeFromArray(RA.map(f)(toReadonlyArray(self))));
/**

@@ -799,3 +798,3 @@ * Statefully maps over the chunk, producing new elements of type `B`.

exports.mapAccum = mapAccum;
const partitionWithIndex = /*#__PURE__*/Dual.dual(2, (self, f) => (([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)])(RA.partitionWithIndex(f)(toReadonlyArray(self))));
const partitionWithIndex = /*#__PURE__*/Dual.dual(2, (self, f) => (([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)])(RA.partition(f)(toReadonlyArray(self))));
/**

@@ -802,0 +801,0 @@ * Separate elements based on a predicate.

10

Context.d.ts

@@ -81,4 +81,4 @@ /**

export declare const add: {
<Services, T extends Tag<any>>(self: Context<Services>, tag: T, service: Tag.Service<T>): Context<Services | Tag.Service<T>>;
<T extends Tag<any>>(tag: T, service: Tag.Service<T>): <Services>(self: Context<Services>) => Context<Tag.Service<T> | Services>;
<Services, T extends Tag<any>>(self: Context<Services>, tag: Tag<T>, service: Tag.Service<T>): Context<Services | Tag.Service<T>>;
};

@@ -90,4 +90,4 @@ /**

export declare const get: {
<Services, T extends Tags<Services>>(tag: T): (self: Context<Services>) => T extends Tag<infer S> ? S : never;
<Services, T extends Tags<Services>>(self: Context<Services>, tag: T): T extends Tag<infer S> ? S : never;
<Services, T extends Tags<Services>>(tag: T): (self: Context<Services>) => T extends Tag<infer S> ? S : never;
};

@@ -99,4 +99,4 @@ /**

export declare const unsafeGet: {
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => S;
<Services, S>(self: Context<Services>, tag: Tag<S>): S;
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => S;
};

@@ -108,4 +108,4 @@ /**

export declare const getOption: {
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => Option<S>;
<Services, S>(self: Context<Services>, tag: Tag<S>): Option<S>;
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => Option<S>;
};

@@ -117,4 +117,4 @@ /**

export declare const merge: {
<R1>(that: Context<R1>): <Services>(self: Context<Services>) => Context<R1 | Services>;
<Services, R1>(self: Context<Services>, that: Context<R1>): Context<Services | R1>;
<R1>(that: Context<R1>): <Services>(self: Context<Services>) => Context<R1 | Services>;
};

@@ -121,0 +121,0 @@ /**

12

Differ.d.ts

@@ -75,4 +75,4 @@ /**

export declare const diff: {
<Value>(oldValue: Value, newValue: Value): <Patch>(differ: Differ<Value, Patch>) => Patch;
<Value, Patch>(differ: Differ<Value, Patch>, oldValue: Value, newValue: Value): Patch;
<Value>(oldValue: Value, newValue: Value): <Patch>(differ: Differ<Value, Patch>) => Patch;
};

@@ -90,4 +90,4 @@ /**

export declare const combine: {
<Patch>(first: Patch, second: Patch): <Value>(self: Differ<Value, Patch>) => Patch;
<Value, Patch>(self: Differ<Value, Patch>, first: Patch, second: Patch): Patch;
<Patch>(first: Patch, second: Patch): <Value>(self: Differ<Value, Patch>) => Patch;
};

@@ -102,4 +102,4 @@ /**

export declare const patch: {
<Patch, Value>(patch: Patch, oldValue: Value): (self: Differ<Value, Patch>) => Value;
<Patch, Value>(self: Differ<Value, Patch>, patch: Patch, oldValue: Value): Value;
<Patch, Value>(patch: Patch, oldValue: Value): (self: Differ<Value, Patch>) => Value;
};

@@ -156,4 +156,4 @@ /**

export declare const orElseResult: {
<Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(self: Differ<Value, Patch>) => Differ<Either<Value, Value2>, OrPatch<Value, Value2, Patch, Patch2>>;
<Value, Patch, Value2, Patch2>(self: Differ<Value, Patch>, that: Differ<Value2, Patch2>): Differ<Either<Value, Value2>, OrPatch<Value, Value2, Patch, Patch2>>;
<Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(self: Differ<Value, Patch>) => Differ<Either<Value, Value2>, OrPatch<Value, Value2, Patch, Patch2>>;
};

@@ -168,4 +168,4 @@ /**

export declare const transform: {
<Value, Value2>(f: (value: Value) => Value2, g: (value: Value2) => Value): <Patch>(self: Differ<Value, Patch>) => Differ<Value2, Patch>;
<Value, Patch, Value2>(self: Differ<Value, Patch>, f: (value: Value) => Value2, g: (value: Value2) => Value): Differ<Value2, Patch>;
<Value, Value2>(f: (value: Value) => Value2, g: (value: Value2) => Value): <Patch>(self: Differ<Value, Patch>) => Differ<Value2, Patch>;
};

@@ -198,6 +198,6 @@ /**

export declare const zip: {
<Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(self: Differ<Value, Patch>) => Differ<readonly [Value, Value2], readonly [Patch, Patch2]>;
<Value, Patch, Value2, Patch2>(self: Differ<Value, Patch>, that: Differ<Value2, Patch2>): Differ<readonly [Value, Value2], readonly [Patch, Patch2]>;
<Value2, Patch2>(that: Differ<Value2, Patch2>): <Value, Patch>(self: Differ<Value, Patch>) => Differ<readonly [Value, Value2], readonly [Patch, Patch2]>;
};
export {};
//# sourceMappingURL=Differ.d.ts.map

2

Differ.js

@@ -7,4 +7,4 @@ "use strict";

exports.zip = exports.updateWith = exports.update = exports.transform = exports.patch = exports.orElseResult = exports.make = exports.hashSet = exports.hashMap = exports.environment = exports.empty = exports.diff = exports.combine = exports.chunk = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var D = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/internal/Differ"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -11,0 +11,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

4

Differ/ChunkPatch.d.ts

@@ -47,4 +47,4 @@ /**

export declare const combine: {
<Value, Patch>(that: ChunkPatch<Value, Patch>): (self: ChunkPatch<Value, Patch>) => ChunkPatch<Value, Patch>;
<Value, Patch>(self: ChunkPatch<Value, Patch>, that: ChunkPatch<Value, Patch>): ChunkPatch<Value, Patch>;
<Value, Patch>(that: ChunkPatch<Value, Patch>): (self: ChunkPatch<Value, Patch>) => ChunkPatch<Value, Patch>;
};

@@ -60,6 +60,6 @@ /**

export declare const patch: {
<Value, Patch>(oldValue: Chunk<Value>, differ: Differ<Value, Patch>): (self: ChunkPatch<Value, Patch>) => Chunk<Value>;
<Value, Patch>(self: ChunkPatch<Value, Patch>, oldValue: Chunk<Value>, differ: Differ<Value, Patch>): Chunk<Value>;
<Value, Patch>(oldValue: Chunk<Value>, differ: Differ<Value, Patch>): (self: ChunkPatch<Value, Patch>) => Chunk<Value>;
};
export {};
//# sourceMappingURL=ChunkPatch.d.ts.map

4

Differ/ContextPatch.d.ts

@@ -45,4 +45,4 @@ /**

export declare const combine: {
<Output, Output2>(that: ContextPatch<Output, Output2>): <Input>(self: ContextPatch<Input, Output>) => ContextPatch<Input, Output2>;
<Input, Output, Output2>(self: ContextPatch<Input, Output>, that: ContextPatch<Output, Output2>): ContextPatch<Input, Output2>;
<Output, Output2>(that: ContextPatch<Output, Output2>): <Input>(self: ContextPatch<Input, Output>) => ContextPatch<Input, Output2>;
};

@@ -57,6 +57,6 @@ /**

export declare const patch: {
<Input>(context: Context<Input>): <Output>(self: ContextPatch<Input, Output>) => Context<Output>;
<Input, Output>(self: ContextPatch<Input, Output>, context: Context<Input>): Context<Output>;
<Input>(context: Context<Input>): <Output>(self: ContextPatch<Input, Output>) => Context<Output>;
};
export {};
//# sourceMappingURL=ContextPatch.d.ts.map

4

Differ/HashMapPatch.d.ts

@@ -48,4 +48,4 @@ /**

export declare const combine: {
<Key, Value, Patch>(that: HashMapPatch<Key, Value, Patch>): (self: HashMapPatch<Key, Value, Patch>) => HashMapPatch<Key, Value, Patch>;
<Key, Value, Patch>(self: HashMapPatch<Key, Value, Patch>, that: HashMapPatch<Key, Value, Patch>): HashMapPatch<Key, Value, Patch>;
<Key, Value, Patch>(that: HashMapPatch<Key, Value, Patch>): (self: HashMapPatch<Key, Value, Patch>) => HashMapPatch<Key, Value, Patch>;
};

@@ -61,6 +61,6 @@ /**

export declare const patch: {
<Key, Value, Patch>(oldValue: HashMap<Key, Value>, differ: Differ<Value, Patch>): (self: HashMapPatch<Key, Value, Patch>) => HashMap<Key, Value>;
<Key, Value, Patch>(self: HashMapPatch<Key, Value, Patch>, oldValue: HashMap<Key, Value>, differ: Differ<Value, Patch>): HashMap<Key, Value>;
<Key, Value, Patch>(oldValue: HashMap<Key, Value>, differ: Differ<Value, Patch>): (self: HashMapPatch<Key, Value, Patch>) => HashMap<Key, Value>;
};
export {};
//# sourceMappingURL=HashMapPatch.d.ts.map

4

Differ/HashSetPatch.d.ts

@@ -44,4 +44,4 @@ /**

export declare const combine: {
<Value>(that: HashSetPatch<Value>): (self: HashSetPatch<Value>) => HashSetPatch<Value>;
<Value>(self: HashSetPatch<Value>, that: HashSetPatch<Value>): HashSetPatch<Value>;
<Value>(that: HashSetPatch<Value>): (self: HashSetPatch<Value>) => HashSetPatch<Value>;
};

@@ -57,6 +57,6 @@ /**

export declare const patch: {
<Value>(oldValue: HashSet<Value>): (self: HashSetPatch<Value>) => HashSet<Value>;
<Value>(self: HashSetPatch<Value>, oldValue: HashSet<Value>): HashSet<Value>;
<Value>(oldValue: HashSet<Value>): (self: HashSetPatch<Value>) => HashSet<Value>;
};
export {};
//# sourceMappingURL=HashSetPatch.d.ts.map

4

Differ/OrPatch.d.ts

@@ -49,4 +49,4 @@ /**

export declare const combine: {
<Value, Value2, Patch, Patch2>(that: OrPatch<Value, Value2, Patch, Patch2>): (self: OrPatch<Value, Value2, Patch, Patch2>) => OrPatch<Value, Value2, Patch, Patch2>;
<Value, Value2, Patch, Patch2>(self: OrPatch<Value, Value2, Patch, Patch2>, that: OrPatch<Value, Value2, Patch, Patch2>): OrPatch<Value, Value2, Patch, Patch2>;
<Value, Value2, Patch, Patch2>(that: OrPatch<Value, Value2, Patch, Patch2>): (self: OrPatch<Value, Value2, Patch, Patch2>) => OrPatch<Value, Value2, Patch, Patch2>;
};

@@ -61,6 +61,6 @@ /**

export declare const patch: {
<Value, Value2, Patch, Patch2>(oldValue: Either<Value, Value2>, left: Differ<Value, Patch>, right: Differ<Value2, Patch2>): (self: OrPatch<Value, Value2, Patch, Patch2>) => Either<Value, Value2>;
<Value, Value2, Patch, Patch2>(self: OrPatch<Value, Value2, Patch, Patch2>, oldValue: Either<Value, Value2>, left: Differ<Value, Patch>, right: Differ<Value2, Patch2>): Either<Value, Value2>;
<Value, Value2, Patch, Patch2>(oldValue: Either<Value, Value2>, left: Differ<Value, Patch>, right: Differ<Value2, Patch2>): (self: OrPatch<Value, Value2, Patch, Patch2>) => Either<Value, Value2>;
};
export {};
//# sourceMappingURL=OrPatch.d.ts.map

12

Duration.d.ts

@@ -65,4 +65,4 @@ declare const TypeId: unique symbol;

export declare const times: {
(times: number): (self: Duration) => Duration;
(self: Duration, times: number): Duration;
(times: number): (self: Duration) => Duration;
};

@@ -74,4 +74,4 @@ /**

export declare const add: {
(that: Duration): (self: Duration) => Duration;
(self: Duration, that: Duration): Duration;
(that: Duration): (self: Duration) => Duration;
};

@@ -83,4 +83,4 @@ /**

export declare const subtract: {
(that: Duration): (self: Duration) => Duration;
(self: Duration, that: Duration): Duration;
(that: Duration): (self: Duration) => Duration;
};

@@ -92,4 +92,4 @@ /**

export declare const lessThan: {
(that: Duration): (self: Duration) => boolean;
(self: Duration, that: Duration): boolean;
(that: Duration): (self: Duration) => boolean;
};

@@ -109,4 +109,4 @@ /**

export declare const greaterThan: {
(that: Duration): (self: Duration) => boolean;
(self: Duration, that: Duration): boolean;
(that: Duration): (self: Duration) => boolean;
};

@@ -126,6 +126,6 @@ /**

export declare const equals: {
(that: Duration): (self: Duration) => boolean;
(self: Duration, that: Duration): boolean;
(that: Duration): (self: Duration) => boolean;
};
export {};
//# sourceMappingURL=Duration.d.ts.map

2

Duration.js

@@ -7,5 +7,5 @@ "use strict";

exports.zero = exports.weeks = exports.times = exports.subtract = exports.seconds = exports.minutes = exports.millis = exports.lessThanOrEqualTo = exports.lessThan = exports.isDuration = exports.infinity = exports.hours = exports.greaterThanOrEqualTo = exports.greaterThan = exports.equals = exports.days = exports.add = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -12,0 +12,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

54

HashMap.d.ts

@@ -66,4 +66,4 @@ /**

export declare const get: {
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>;
<K, V, K1>(self: HashMap<K, V>, key: K1): Option<V>;
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>;
};

@@ -77,4 +77,4 @@ /**

export declare const getHash: {
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>;
<K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): Option<V>;
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>;
};

@@ -89,4 +89,4 @@ /**

export declare const unsafeGet: {
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => V;
<K, V, K1>(self: HashMap<K, V>, key: K1): V;
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => V;
};

@@ -100,4 +100,4 @@ /**

export declare const has: {
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean;
<K, V, K1>(self: HashMap<K, V>, key: K1): boolean;
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean;
};

@@ -112,4 +112,4 @@ /**

export declare const hasHash: {
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean;
<K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): boolean;
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean;
};

@@ -124,4 +124,4 @@ /**

export declare const set: {
<K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V>;
<K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -177,4 +177,4 @@ /**

export declare const mutate: {
<K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, f: (self: HashMap<K, V>) => void): HashMap<K, V>;
<K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -193,4 +193,4 @@ /**

export declare const modifyAt: {
<K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, key: K, f: UpdateFn<V>): HashMap<K, V>;
<K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -211,4 +211,4 @@ /**

export declare const modifyHash: {
<K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V>;
<K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -222,4 +222,4 @@ /**

export declare const modify: {
<K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V>;
<K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -233,4 +233,4 @@ /**

export declare const union: {
<K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>;
<K0, V0, K1, V1>(self: HashMap<K0, V0>, that: HashMap<K1, V1>): HashMap<K0 | K1, V0 | V1>;
<K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>;
};

@@ -245,4 +245,4 @@ /**

export declare const remove: {
<K>(key: K): <V>(self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, key: K): HashMap<K, V>;
<K>(key: K): <V>(self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -256,4 +256,4 @@ /**

export declare const removeMany: {
<K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>;
<K, V>(self: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V>;
<K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>;
};

@@ -267,4 +267,4 @@ /**

export declare const map: {
<V, A>(f: (value: V) => A): <K>(self: HashMap<K, V>) => HashMap<K, A>;
<K, V, A>(self: HashMap<K, V>, f: (value: V) => A): HashMap<K, A>;
<V, A>(f: (value: V) => A): <K>(self: HashMap<K, V>) => HashMap<K, A>;
};

@@ -278,4 +278,4 @@ /**

export declare const mapWithIndex: {
<A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>;
<K, V, A>(self: HashMap<K, V>, f: (value: V, key: K) => A): HashMap<K, A>;
<A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>;
};

@@ -291,4 +291,4 @@ /**

export declare const flatMap: {
<K, A, B>(f: (value: A) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
<K, A, B>(self: HashMap<K, A>, f: (value: A) => HashMap<K, B>): HashMap<K, B>;
<K, A, B>(f: (value: A) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
};

@@ -304,4 +304,4 @@ /**

export declare const flatMapWithIndex: {
<A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
<K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => HashMap<K, B>): HashMap<K, B>;
<A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>;
};

@@ -315,4 +315,4 @@ /**

export declare const forEach: {
<V>(f: (value: V) => void): <K>(self: HashMap<K, V>) => void;
<K, V>(self: HashMap<K, V>, f: (value: V) => void): void;
<V>(f: (value: V) => void): <K>(self: HashMap<K, V>) => void;
};

@@ -326,4 +326,4 @@ /**

export declare const forEachWithIndex: {
<V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void;
<V, K>(self: HashMap<K, V>, f: (value: V, key: K) => void): void;
<V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void;
};

@@ -337,4 +337,4 @@ /**

export declare const reduce: {
<V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(self: HashMap<K, V>) => Z;
<K, V, Z>(self: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z;
<V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(self: HashMap<K, V>) => Z;
};

@@ -348,4 +348,4 @@ /**

export declare const reduceWithIndex: {
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z;
<Z, V, K>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z;
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z;
};

@@ -359,6 +359,6 @@ /**

export declare const filter: {
<A, B extends A>(f: Refinement<A, B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
<A>(f: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>;
<K, A, B extends A>(self: HashMap<K, A>, f: Refinement<A, B>): HashMap<K, B>;
<K, A>(self: HashMap<K, A>, f: Predicate<A>): HashMap<K, A>;
<A, B extends A>(f: Refinement<A, B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
<A>(f: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>;
};

@@ -372,6 +372,6 @@ /**

export declare const filterWithIndex: {
<K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>;
<K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>;
<K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>;
<K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>;
<K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>;
<K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>;
};

@@ -393,4 +393,4 @@ /**

export declare const filterMap: {
<A, B>(f: (value: A) => Option<B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
<K, A, B>(self: HashMap<K, A>, f: (value: A) => Option<B>): HashMap<K, B>;
<A, B>(f: (value: A) => Option<B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
};

@@ -405,6 +405,6 @@ /**

export declare const filterMapWithIndex: {
<A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>;
<K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option<B>): HashMap<K, B>;
<A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>;
};
export {};
//# sourceMappingURL=HashMap.d.ts.map

38

HashSet.d.ts

@@ -55,4 +55,4 @@ /**

export declare const has: {
<A>(value: A): (self: HashSet<A>) => boolean;
<A>(self: HashSet<A>, value: A): boolean;
<A>(value: A): (self: HashSet<A>) => boolean;
};

@@ -66,4 +66,4 @@ /**

export declare const some: {
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean;
<A>(self: HashSet<A>, f: Predicate<A>): boolean;
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean;
};

@@ -78,4 +78,4 @@ /**

export declare const every: {
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean;
<A>(self: HashSet<A>, f: Predicate<A>): boolean;
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean;
};

@@ -92,4 +92,4 @@ /**

export declare const isSubset: {
<A>(that: HashSet<A>): (self: HashSet<A>) => boolean;
<A>(self: HashSet<A>, that: HashSet<A>): boolean;
<A>(that: HashSet<A>): (self: HashSet<A>) => boolean;
};

@@ -131,4 +131,4 @@ /**

export declare const mutate: {
<A>(f: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, f: (set: HashSet<A>) => void): HashSet<A>;
<A>(f: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>;
};

@@ -142,4 +142,4 @@ /**

export declare const add: {
<A>(value: A): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, value: A): HashSet<A>;
<A>(value: A): (self: HashSet<A>) => HashSet<A>;
};

@@ -153,4 +153,4 @@ /**

export declare const remove: {
<A>(value: A): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, value: A): HashSet<A>;
<A>(value: A): (self: HashSet<A>) => HashSet<A>;
};

@@ -168,4 +168,4 @@ /**

export declare const difference: {
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>;
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
};

@@ -183,4 +183,4 @@ /**

export declare const intersection: {
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>;
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
};

@@ -198,4 +198,4 @@ /**

export declare const union: {
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>;
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
};

@@ -211,4 +211,4 @@ /**

export declare const toggle: {
<A>(value: A): (self: HashSet<A>) => HashSet<A>;
<A>(self: HashSet<A>, value: A): HashSet<A>;
<A>(value: A): (self: HashSet<A>) => HashSet<A>;
};

@@ -222,4 +222,4 @@ /**

export declare const map: {
<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
<A, B>(self: HashSet<A>, f: (a: A) => B): HashSet<B>;
<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
};

@@ -233,4 +233,4 @@ /**

export declare const flatMap: {
<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
<A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>): HashSet<B>;
<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
};

@@ -244,4 +244,4 @@ /**

export declare const forEach: {
<A>(f: (value: A) => void): (self: HashSet<A>) => void;
<A>(self: HashSet<A>, f: (value: A) => void): void;
<A>(f: (value: A) => void): (self: HashSet<A>) => void;
};

@@ -255,4 +255,4 @@ /**

export declare const reduce: {
<A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet<A>) => Z;
<A, Z>(self: HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): Z;
<A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet<A>) => Z;
};

@@ -266,6 +266,6 @@ /**

export declare const filter: {
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>;
<A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>;
<A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): HashSet<B>;
<A>(self: HashSet<A>, f: Predicate<A>): HashSet<A>;
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>;
<A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>;
};

@@ -283,8 +283,8 @@ /**

export declare const partition: {
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<B>];
<A>(f: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>];
<A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): readonly [HashSet<A>, HashSet<B>];
<A>(self: HashSet<A>, f: Predicate<A>): readonly [HashSet<A>, HashSet<A>];
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<B>];
<A>(f: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>];
};
export {};
//# sourceMappingURL=HashSet.d.ts.map

5

index.d.ts

@@ -14,3 +14,2 @@ /**

import * as orPatch from "@effect/data/Differ/OrPatch";
import * as dual from "@effect/data/Dual";
import * as duration from "@effect/data/Duration";

@@ -65,6 +64,2 @@ import * as equal from "@effect/data/Equal";

*/
dual,
/**
* @since 1.0.0
*/
duration,

@@ -71,0 +66,0 @@ /**

4

index.js

@@ -6,3 +6,3 @@ "use strict";

});
exports.sortedSet = exports.sortedMap = exports.redBlackTree = exports.random = exports.orPatch = exports.nonEmpty = exports.mutableRef = exports.mutableQueue = exports.mutableList = exports.mutableHashSet = exports.mutableHashMap = exports.list = exports.hashSetPatch = exports.hashSet = exports.hashMapPatch = exports.hashMap = exports.hash = exports.gen = exports.equal = exports.duration = exports.dual = exports.differ = exports.data = exports.contextPatch = exports.context = exports.chunkPatch = exports.chunk = exports.brand = void 0;
exports.sortedSet = exports.sortedMap = exports.redBlackTree = exports.random = exports.orPatch = exports.nonEmpty = exports.mutableRef = exports.mutableQueue = exports.mutableList = exports.mutableHashSet = exports.mutableHashMap = exports.list = exports.hashSetPatch = exports.hashSet = exports.hashMapPatch = exports.hashMap = exports.hash = exports.gen = exports.equal = exports.duration = exports.differ = exports.data = exports.contextPatch = exports.context = exports.chunkPatch = exports.chunk = exports.brand = void 0;
var brand = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Brand"));

@@ -28,4 +28,2 @@ exports.brand = brand;

exports.orPatch = orPatch;
var dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
exports.dual = dual;
var duration = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Duration"));

@@ -32,0 +30,0 @@ exports.duration = duration;

2

internal/Context.js

@@ -7,5 +7,5 @@ "use strict";

exports.unsafeGet = exports.prune = exports.merge = exports.make = exports.isTag = exports.isContext = exports.getOption = exports.get = exports.empty = exports.add = exports.TagTypeId = exports.TagImpl = exports.ContextTypeId = exports.ContextImpl = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -12,0 +12,0 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

17

internal/Differ.js

@@ -12,5 +12,4 @@ "use strict";

var OrPatch = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Differ/OrPatch"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var _Function = /*#__PURE__*/require("@fp-ts/core/Function");
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -25,4 +24,4 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

this._id = DifferTypeId;
this._P = _Function.identity;
this._V = _Function.identity;
this._P = Dual.identity;
this._V = Dual.identity;
this.empty = params.empty;

@@ -90,8 +89,8 @@ this.diff = params.diff;

const updateWith = f => make({
empty: _Function.identity,
empty: Dual.identity,
combine: (first, second) => {
if (first === _Function.identity) {
if (first === Dual.identity) {
return second;
}
if (second === _Function.identity) {
if (second === Dual.identity) {
return first;

@@ -103,5 +102,5 @@ }

if (Equal.equals(oldValue, newValue)) {
return _Function.identity;
return Dual.identity;
}
return (0, _Function.constant)(newValue);
return (0, Dual.constant)(newValue);
},

@@ -108,0 +107,0 @@ patch: (patch, oldValue) => f(oldValue, patch(oldValue))

2

internal/Differ/ChunkPatch.js

@@ -8,5 +8,5 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -13,0 +13,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

2

internal/Differ/ContextPatch.js

@@ -8,6 +8,6 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var _Context = /*#__PURE__*/require("@effect/data/internal/Context");
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -14,0 +14,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

2

internal/Differ/HashMapPatch.js

@@ -8,6 +8,6 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var HashMap = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/HashMap"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -14,0 +14,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

2

internal/Differ/HashSetPatch.js

@@ -8,6 +8,6 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var HashSet = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/HashSet"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -14,0 +14,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

2

internal/Differ/OrPatch.js

@@ -8,6 +8,6 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var E = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Either"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -14,0 +14,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

2

internal/HashMap.d.ts

@@ -8,3 +8,3 @@ import type * as HM from "@effect/data/HashMap";

*/
export declare const mapWithIndex: (<K, V, A>(self: HM.HashMap<K, V>, f: (value: V, key: K) => A) => HM.HashMap<K, A>) & (<A_1, V_1, K_1>(f: (value: V_1, key: K_1) => A_1) => (self: HM.HashMap<K_1, V_1>) => HM.HashMap<K_1, A_1>);
export declare const mapWithIndex: (<A, V, K>(f: (value: V, key: K) => A) => (self: HM.HashMap<K, V>) => HM.HashMap<K, A>) & (<K_1, V_1, A_1>(self: HM.HashMap<K_1, V_1>, f: (value: V_1, key: K_1) => A_1) => HM.HashMap<K_1, A_1>);
//# sourceMappingURL=HashMap.d.ts.map

5

internal/HashMap.js

@@ -7,3 +7,2 @@ "use strict";

exports.values = exports.unsafeGet = exports.union = exports.size = exports.setTree = exports.set = exports.removeMany = exports.remove = exports.reduceWithIndex = exports.reduce = exports.mutate = exports.modifyHash = exports.modifyAt = exports.modify = exports.mapWithIndex = exports.map = exports.make = exports.keys = exports.isHashMap = exports.isEmpty = exports.hasHash = exports.has = exports.getHash = exports.get = exports.fromIterable = exports.forEachWithIndex = exports.forEach = exports.flatMapWithIndex = exports.flatMap = exports.filterWithIndex = exports.filterMapWithIndex = exports.filterMap = exports.filter = exports.endMutation = exports.empty = exports.compact = exports.beginMutation = exports.HashMapTypeId = exports.HashMapImpl = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));

@@ -14,3 +13,3 @@ var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));

var Node = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/internal/HashMap/node"));
var _Function = /*#__PURE__*/require("@fp-ts/core/Function");
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -361,3 +360,3 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

exports.filterWithIndex = filterWithIndex;
const compact = self => filterMap(self, _Function.identity);
const compact = self => filterMap(self, Dual.identity);
/** @internal */

@@ -364,0 +363,0 @@ exports.compact = compact;

2

internal/HashSet.js

@@ -7,6 +7,6 @@ "use strict";

exports.values = exports.union = exports.toggle = exports.some = exports.size = exports.remove = exports.reduce = exports.partition = exports.mutate = exports.map = exports.make = exports.isSubset = exports.isHashSet = exports.intersection = exports.has = exports.fromIterable = exports.forEach = exports.flatMap = exports.filter = exports.every = exports.endMutation = exports.empty = exports.difference = exports.beginMutation = exports.add = exports.HashSetTypeId = exports.HashSetImpl = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var HM = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/internal/HashMap"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -13,0 +13,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

2

internal/RedBlackTree.js

@@ -8,3 +8,2 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));

@@ -15,2 +14,3 @@ var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));

var _Stack = /*#__PURE__*/require("@effect/data/internal/Stack");
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -17,0 +17,0 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

44

List.d.ts

@@ -121,4 +121,4 @@ /**

export declare const equalsWith: {
<A, B>(that: List<B>, f: (a: A, b: B) => boolean): (self: List<A>) => boolean;
<A, B>(self: List<A>, that: List<B>, f: (a: A, b: B) => boolean): boolean;
<A, B>(that: List<B>, f: (a: A, b: B) => boolean): (self: List<A>) => boolean;
};

@@ -181,4 +181,4 @@ /**

export declare const concat: {
<B>(that: List<B>): <A>(self: List<A>) => List<A | B>;
<A, B>(self: List<A>, that: List<B>): List<A | B>;
<B>(that: List<B>): <A>(self: List<A>) => List<A | B>;
};

@@ -192,4 +192,4 @@ /**

export declare const drop: {
(n: number): <A>(self: List<A>) => List<A>;
<A>(self: List<A>, n: number): List<A>;
(n: number): <A>(self: List<A>) => List<A>;
};

@@ -204,4 +204,4 @@ /**

export declare const every: {
<A>(predicate: Predicate<A>): (self: List<A>) => boolean;
<A>(self: List<A>, predicate: Predicate<A>): boolean;
<A>(predicate: Predicate<A>): (self: List<A>) => boolean;
};

@@ -215,6 +215,6 @@ /**

export declare const filter: {
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>;
<A>(predicate: Predicate<A>): (self: List<A>) => List<A>;
<A, B extends A>(self: List<A>, refinement: Refinement<A, B>): List<B>;
<A>(self: List<A>, predicate: Predicate<A>): List<A>;
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>;
<A>(predicate: Predicate<A>): (self: List<A>) => List<A>;
};

@@ -230,4 +230,4 @@ /**

export declare const filterMap: {
<A, B>(pf: (a: A) => Option.Option<B>): (self: Iterable<A>) => List<B>;
<A, B>(self: Iterable<A>, pf: (a: A) => Option.Option<B>): List<B>;
<A, B>(pf: (a: A) => Option.Option<B>): (self: Iterable<A>) => List<B>;
};

@@ -242,6 +242,6 @@ /**

export declare const findFirst: {
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>;
<A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>;
<A, B extends A>(self: List<A>, refinement: Refinement<A, B>): Option.Option<B>;
<A>(self: List<A>, predicate: Predicate<A>): Option.Option<A>;
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>;
<A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>;
};

@@ -255,4 +255,4 @@ /**

export declare const flatMap: {
<A, B>(f: (a: A) => List<B>): (self: List<A>) => List<B>;
<A, B>(self: List<A>, f: (a: A) => List<B>): List<B>;
<A, B>(f: (a: A) => List<B>): (self: List<A>) => List<B>;
};

@@ -266,4 +266,4 @@ /**

export declare const forEach: {
<A, B>(f: (a: A) => B): (self: List<A>) => void;
<A, B>(self: List<A>, f: (a: A) => B): void;
<A, B>(f: (a: A) => B): (self: List<A>) => void;
};

@@ -293,4 +293,4 @@ /**

export declare const map: {
<A, B>(f: (a: A) => B): (self: List<A>) => List<B>;
<A, B>(self: List<A>, f: (a: A) => B): List<B>;
<A, B>(f: (a: A) => B): (self: List<A>) => List<B>;
};

@@ -306,4 +306,4 @@ /**

export declare const partition: {
<A>(predicate: Predicate<A>): (self: List<A>) => readonly [List<A>, List<A>];
<A>(self: List<A>, predicate: Predicate<A>): readonly [List<A>, List<A>];
<A>(predicate: Predicate<A>): (self: List<A>) => readonly [List<A>, List<A>];
};

@@ -319,4 +319,4 @@ /**

export declare const partitionMap: {
<A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => readonly [List<B>, List<C>];
<A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): readonly [List<B>, List<C>];
<A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => readonly [List<B>, List<C>];
};

@@ -330,4 +330,4 @@ /**

export declare const prepend: {
<B>(element: B): <A>(self: List<A>) => Cons<A | B>;
<A, B>(self: List<A>, element: B): Cons<A | B>;
<B>(element: B): <A>(self: List<A>) => Cons<A | B>;
};

@@ -341,4 +341,4 @@ /**

export declare const prependAll: {
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>;
<A, B>(self: List<A>, prefix: List<B>): List<A | B>;
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>;
};

@@ -353,4 +353,4 @@ /**

export declare const prependAllReversed: {
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>;
<A, B>(self: List<A>, prefix: List<B>): List<A | B>;
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>;
};

@@ -365,4 +365,4 @@ /**

export declare const reduce: {
<Z, A>(zero: Z, f: (b: Z, a: A) => Z): (self: List<A>) => Z;
<A, Z>(self: List<A>, zero: Z, f: (b: Z, a: A) => Z): Z;
<Z, A>(zero: Z, f: (b: Z, a: A) => Z): (self: List<A>) => Z;
};

@@ -377,4 +377,4 @@ /**

export declare const reduceRight: {
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: List<A>) => Z;
<Z, A>(self: List<A>, zero: Z, f: (accumulator: Z, value: A) => Z): Z;
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: List<A>) => Z;
};

@@ -396,4 +396,4 @@ /**

export declare const some: {
<A>(predicate: Predicate<A>): (self: List<A>) => boolean;
<A>(self: List<A>, predicate: Predicate<A>): boolean;
<A>(predicate: Predicate<A>): (self: List<A>) => boolean;
};

@@ -407,4 +407,4 @@ /**

export declare const splitAt: {
(n: number): <A>(self: List<A>) => readonly [List<A>, List<A>];
<A>(self: List<A>, n: number): readonly [List<A>, List<A>];
(n: number): <A>(self: List<A>) => readonly [List<A>, List<A>];
};

@@ -426,4 +426,4 @@ /**

export declare const take: {
(n: number): <A>(self: List<A>) => List<A>;
<A>(self: List<A>, n: number): List<A>;
(n: number): <A>(self: List<A>) => List<A>;
};

@@ -430,0 +430,0 @@ /**

15

List.js

@@ -8,7 +8,6 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var Either = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Either"));
var _Function = /*#__PURE__*/require("@fp-ts/core/Function");
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -268,3 +267,3 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

exports.make = make;
const compact = self => filterMap(self, _Function.identity);
const compact = self => filterMap(self, Dual.identity);
/**

@@ -743,7 +742,7 @@ * Concatentates the specified lists together.

currentLast.tail = newElem;
currentLast = (0, _Function.unsafeCoerce)(newElem);
toProcess = (0, _Function.unsafeCoerce)(toProcess.tail);
currentLast = (0, Dual.unsafeCoerce)(newElem);
toProcess = (0, Dual.unsafeCoerce)(toProcess.tail);
}
let next = firstMiss.tail;
let nextToCopy = (0, _Function.unsafeCoerce)(next);
let nextToCopy = (0, Dual.unsafeCoerce)(next);
while (!isNil(next)) {

@@ -758,5 +757,5 @@ const head = unsafeHead(next);

currentLast = newElem;
nextToCopy = (0, _Function.unsafeCoerce)(nextToCopy.tail);
nextToCopy = (0, Dual.unsafeCoerce)(nextToCopy.tail);
}
nextToCopy = (0, _Function.unsafeCoerce)(next.tail);
nextToCopy = (0, Dual.unsafeCoerce)(next.tail);
next = next.tail;

@@ -763,0 +762,0 @@ }

12

MutableHashMap.d.ts

@@ -35,4 +35,4 @@ import * as Option from "@fp-ts/core/Option";

export declare const get: {
<K>(key: K): <V>(self: MutableHashMap<K, V>) => Option.Option<V>;
<K, V>(self: MutableHashMap<K, V>, key: K): Option.Option<V>;
<K>(key: K): <V>(self: MutableHashMap<K, V>) => Option.Option<V>;
};

@@ -44,4 +44,4 @@ /**

export declare const has: {
<K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean;
<K, V>(self: MutableHashMap<K, V>, key: K): boolean;
<K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean;
};

@@ -55,4 +55,4 @@ /**

export declare const modify: {
<K, V>(key: K, f: (v: V) => V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
<K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V): MutableHashMap<K, V>;
<K, V>(key: K, f: (v: V) => V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
};

@@ -67,4 +67,4 @@ /**

export declare const modifyAt: {
<K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
<K, V>(self: MutableHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): MutableHashMap<K, V>;
<K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
};

@@ -76,4 +76,4 @@ /**

export declare const remove: {
<K>(key: K): <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
<K, V>(self: MutableHashMap<K, V>, key: K): MutableHashMap<K, V>;
<K>(key: K): <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
};

@@ -85,4 +85,4 @@ /**

export declare const set: {
<K, V>(key: K, value: V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
<K, V>(self: MutableHashMap<K, V>, key: K, value: V): MutableHashMap<K, V>;
<K, V>(key: K, value: V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>;
};

@@ -89,0 +89,0 @@ /**

2

MutableHashMap.js

@@ -7,5 +7,5 @@ "use strict";

exports.size = exports.set = exports.remove = exports.modifyAt = exports.modify = exports.make = exports.has = exports.get = exports.fromIterable = exports.empty = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -12,0 +12,0 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

6

MutableHashSet.d.ts

@@ -35,4 +35,4 @@ declare const TypeId: unique symbol;

export declare const add: {
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
<V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
};

@@ -44,4 +44,4 @@ /**

export declare const has: {
<V>(key: V): (self: MutableHashSet<V>) => boolean;
<V>(self: MutableHashSet<V>, key: V): boolean;
<V>(key: V): (self: MutableHashSet<V>) => boolean;
};

@@ -53,4 +53,4 @@ /**

export declare const remove: {
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
<V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>;
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>;
};

@@ -57,0 +57,0 @@ /**

2

MutableHashSet.js

@@ -7,4 +7,4 @@ "use strict";

exports.size = exports.remove = exports.make = exports.has = exports.fromIterable = exports.empty = exports.add = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var MutableHashMap = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/MutableHashMap"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -11,0 +11,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

4

MutableList.d.ts

@@ -70,4 +70,4 @@ declare const TypeId: unique symbol;

export declare const forEach: {
<A>(f: (element: A) => void): (self: MutableList<A>) => void;
<A>(self: MutableList<A>, f: (element: A) => void): void;
<A>(f: (element: A) => void): (self: MutableList<A>) => void;
};

@@ -88,4 +88,4 @@ /**

export declare const append: {
<A>(value: A): (self: MutableList<A>) => MutableList<A>;
<A>(self: MutableList<A>, value: A): MutableList<A>;
<A>(value: A): (self: MutableList<A>) => MutableList<A>;
};

@@ -92,0 +92,0 @@ /**

2

MutableList.js

@@ -7,3 +7,3 @@ "use strict";

exports.tail = exports.shift = exports.reset = exports.pop = exports.make = exports.length = exports.isEmpty = exports.head = exports.from = exports.forEach = exports.empty = exports.append = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -10,0 +10,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

6

MutableQueue.d.ts

@@ -95,4 +95,4 @@ /**

export declare const offerAll: {
<A>(values: Iterable<A>): (self: MutableQueue<A>) => Chunk.Chunk<A>;
<A>(self: MutableQueue<A>, values: Iterable<A>): Chunk.Chunk<A>;
<A>(values: Iterable<A>): (self: MutableQueue<A>) => Chunk.Chunk<A>;
};

@@ -111,4 +111,4 @@ /**

export declare const poll: {
<D>(def: D): <A>(self: MutableQueue<A>) => D | A;
<A, D>(self: MutableQueue<A>, def: D): A | D;
<D>(def: D): <A>(self: MutableQueue<A>) => D | A;
};

@@ -124,6 +124,6 @@ /**

export declare const pollUpTo: {
(n: number): <A>(self: MutableQueue<A>) => Chunk.Chunk<A>;
<A>(self: MutableQueue<A>, n: number): Chunk.Chunk<A>;
(n: number): <A>(self: MutableQueue<A>) => Chunk.Chunk<A>;
};
export {};
//# sourceMappingURL=MutableQueue.d.ts.map

2

MutableQueue.js

@@ -8,4 +8,4 @@ "use strict";

var Chunk = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Chunk"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var MutableList = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/MutableList"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -12,0 +12,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

14

MutableRef.d.ts

@@ -70,4 +70,4 @@ declare const TypeId: unique symbol;

export declare const compareAndSet: {
<T>(oldValue: T, newValue: T): (self: MutableRef<T>) => boolean;
<T>(self: MutableRef<T>, oldValue: T, newValue: T): boolean;
<T>(oldValue: T, newValue: T): (self: MutableRef<T>) => boolean;
};

@@ -104,4 +104,4 @@ /**

export declare const getAndSet: {
<T>(value: T): (self: MutableRef<T>) => T;
<T>(self: MutableRef<T>, value: T): T;
<T>(value: T): (self: MutableRef<T>) => T;
};

@@ -113,4 +113,4 @@ /**

export declare const getAndUpdate: {
<T>(f: (value: T) => T): (self: MutableRef<T>) => T;
<T>(self: MutableRef<T>, f: (value: T) => T): T;
<T>(f: (value: T) => T): (self: MutableRef<T>) => T;
};

@@ -132,4 +132,4 @@ /**

export declare const set: {
<T>(value: T): (self: MutableRef<T>) => MutableRef<T>;
<T>(self: MutableRef<T>, value: T): MutableRef<T>;
<T>(value: T): (self: MutableRef<T>) => MutableRef<T>;
};

@@ -141,4 +141,4 @@ /**

export declare const setAndGet: {
<T>(value: T): (self: MutableRef<T>) => T;
<T>(self: MutableRef<T>, value: T): T;
<T>(value: T): (self: MutableRef<T>) => T;
};

@@ -150,4 +150,4 @@ /**

export declare const update: {
<T>(f: (value: T) => T): (self: MutableRef<T>) => MutableRef<T>;
<T>(self: MutableRef<T>, f: (value: T) => T): MutableRef<T>;
<T>(f: (value: T) => T): (self: MutableRef<T>) => MutableRef<T>;
};

@@ -159,4 +159,4 @@ /**

export declare const updateAndGet: {
<T>(f: (value: T) => T): (self: MutableRef<T>) => T;
<T>(self: MutableRef<T>, f: (value: T) => T): T;
<T>(f: (value: T) => T): (self: MutableRef<T>) => T;
};

@@ -163,0 +163,0 @@ /**

2

MutableRef.js

@@ -7,4 +7,4 @@ "use strict";

exports.updateAndGet = exports.update = exports.toggle = exports.setAndGet = exports.set = exports.make = exports.incrementAndGet = exports.increment = exports.getAndUpdate = exports.getAndSet = exports.getAndIncrement = exports.getAndDecrement = exports.get = exports.decrementAndGet = exports.decrement = exports.compareAndSet = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -11,0 +11,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

4

package.json
{
"name": "@effect/data",
"version": "0.0.1",
"version": "0.1.0",
"license": "MIT",

@@ -10,3 +10,3 @@ "repository": {

"dependencies": {
"@fp-ts/core": "~0.1.1"
"@fp-ts/core": "~0.2.0"
},

@@ -13,0 +13,0 @@ "main": "./index.js",

44

RedBlackTree.d.ts

@@ -78,4 +78,4 @@ /**

export declare const at: {
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, index: number): Iterable<readonly [K, V]>;
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -92,4 +92,4 @@ /**

export declare const atReversed: {
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, index: number): Iterable<readonly [K, V]>;
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -103,4 +103,4 @@ /**

export declare const find: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>;
<K, V>(self: RedBlackTree<K, V>, key: K): Chunk<V>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>;
};

@@ -114,4 +114,4 @@ /**

export declare const findFirst: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>;
<K, V>(self: RedBlackTree<K, V>, key: K): Option<V>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>;
};

@@ -133,4 +133,4 @@ /**

export declare const getAt: {
(index: number): <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, index: number): Option<readonly [K, V]>;
(index: number): <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]>;
};

@@ -152,4 +152,4 @@ /**

export declare const greaterThan: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -164,4 +164,4 @@ /**

export declare const greaterThanReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -176,4 +176,4 @@ /**

export declare const greaterThanEqual: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -188,4 +188,4 @@ /**

export declare const greaterThanEqualReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -199,4 +199,4 @@ /**

export declare const has: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean;
<K, V>(self: RedBlackTree<K, V>, key: K): boolean;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean;
};

@@ -210,4 +210,4 @@ /**

export declare const insert: {
<K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>;
<K, V>(self: RedBlackTree<K, V>, key: K, value: V): RedBlackTree<K, V>;
<K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>;
};

@@ -243,4 +243,4 @@ /**

export declare const lessThan: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -255,4 +255,4 @@ /**

export declare const lessThanReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -267,4 +267,4 @@ /**

export declare const lessThanEqual: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -279,4 +279,4 @@ /**

export declare const lessThanEqualReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>;
};

@@ -290,4 +290,4 @@ /**

export declare const forEach: {
<K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
<K, V>(self: RedBlackTree<K, V>, f: (key: K, value: V) => void): void;
<K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
};

@@ -301,4 +301,4 @@ /**

export declare const forEachGreaterThanEqual: {
<K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
<K, V>(self: RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void): void;
<K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
};

@@ -312,4 +312,4 @@ /**

export declare const forEachLessThan: {
<K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
<K, V>(self: RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void): void;
<K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
};

@@ -324,4 +324,4 @@ /**

export declare const forEachBetween: {
<K, V>(min: K, max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
<K, V>(self: RedBlackTree<K, V>, min: K, max: K, f: (key: K, value: V) => void): void;
<K, V>(min: K, max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void;
};

@@ -335,4 +335,4 @@ /**

export declare const reduce: {
<Z, V>(zero: Z, f: (accumulator: Z, value: V) => Z): <K>(self: RedBlackTree<K, V>) => Z;
<Z, K, V>(self: RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V) => Z): Z;
<Z, V>(zero: Z, f: (accumulator: Z, value: V) => Z): <K>(self: RedBlackTree<K, V>) => Z;
};

@@ -346,4 +346,4 @@ /**

export declare const reduceWithIndex: {
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z;
<Z, V, K>(self: RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z;
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z;
};

@@ -357,4 +357,4 @@ /**

export declare const removeFirst: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>;
<K, V>(self: RedBlackTree<K, V>, key: K): RedBlackTree<K, V>;
<K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>;
};

@@ -361,0 +361,0 @@ /**

19

SortedMap.d.ts

@@ -0,1 +1,4 @@

/**
* @since 1.0.0
*/
import * as Equal from "@effect/data/Equal";

@@ -60,4 +63,4 @@ import * as Option from "@fp-ts/core/Option";

export declare const get: {
<K>(key: K): <V>(self: SortedMap<K, V>) => Option.Option<V>;
<K, V>(self: SortedMap<K, V>, key: K): Option.Option<V>;
<K>(key: K): <V>(self: SortedMap<K, V>) => Option.Option<V>;
};

@@ -76,4 +79,4 @@ /**

export declare const has: {
<K>(key: K): <V>(self: SortedMap<K, V>) => boolean;
<K, V>(self: SortedMap<K, V>, key: K): boolean;
<K>(key: K): <V>(self: SortedMap<K, V>) => boolean;
};

@@ -90,4 +93,4 @@ /**

export declare const map: {
<A, B>(f: (a: A) => B): <K>(self: SortedMap<K, A>) => SortedMap<K, B>;
<K, A, B>(self: SortedMap<K, A>, f: (a: A) => B): SortedMap<K, B>;
<A, B>(f: (a: A) => B): <K>(self: SortedMap<K, A>) => SortedMap<K, B>;
};

@@ -99,4 +102,4 @@ /**

export declare const mapWithIndex: {
<A, K, B>(f: (a: A, k: K) => B): (self: SortedMap<K, A>) => SortedMap<K, B>;
<K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B): SortedMap<K, B>;
<A, K, B>(f: (a: A, k: K) => B): (self: SortedMap<K, A>) => SortedMap<K, B>;
};

@@ -113,4 +116,4 @@ /**

export declare const reduce: {
<V, B>(zero: B, f: (accumulator: B, value: V) => B): <K>(self: SortedMap<K, V>) => B;
<K, V, B>(self: SortedMap<K, V>, zero: B, f: (accumulator: B, value: V) => B): B;
<V, B>(zero: B, f: (accumulator: B, value: V) => B): <K>(self: SortedMap<K, V>) => B;
};

@@ -122,4 +125,4 @@ /**

export declare const reduceWithIndex: {
<B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B): (self: SortedMap<K, A>) => B;
<K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B): B;
<B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B): (self: SortedMap<K, A>) => B;
};

@@ -131,4 +134,4 @@ /**

export declare const remove: {
<K>(key: K): <V>(self: SortedMap<K, V>) => SortedMap<K, V>;
<K, V>(self: SortedMap<K, V>, key: K): SortedMap<K, V>;
<K>(key: K): <V>(self: SortedMap<K, V>) => SortedMap<K, V>;
};

@@ -140,4 +143,4 @@ /**

export declare const set: {
<K, V>(key: K, value: V): (self: SortedMap<K, V>) => SortedMap<K, V>;
<K, V>(self: SortedMap<K, V>, key: K, value: V): SortedMap<K, V>;
<K, V>(key: K, value: V): (self: SortedMap<K, V>) => SortedMap<K, V>;
};

@@ -144,0 +147,0 @@ /**

2

SortedMap.js

@@ -7,6 +7,6 @@ "use strict";

exports.values = exports.size = exports.set = exports.remove = exports.reduceWithIndex = exports.reduce = exports.mapWithIndex = exports.map = exports.make = exports.keys = exports.isSortedMap = exports.isNonEmpty = exports.isEmpty = exports.headOption = exports.has = exports.getOrder = exports.get = exports.fromIterable = exports.entries = exports.empty = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var RBT = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/RedBlackTree"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
var Option = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Option"));

@@ -13,0 +13,0 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

37

SortedSet.d.ts

@@ -0,1 +1,4 @@

/**
* @since 1.0.0
*/
import * as Equal from "@effect/data/Equal";

@@ -45,4 +48,4 @@ import type { Predicate, Refinement } from "@fp-ts/core/Predicate";

export declare const add: {
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
<A>(self: SortedSet<A>, value: A): SortedSet<A>;
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -54,4 +57,4 @@ /**

export declare const difference: {
<A, B extends A>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>;
<A, B extends A>(self: SortedSet<A>, that: Iterable<B>): SortedSet<A>;
<A, B extends A>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -63,4 +66,4 @@ /**

export declare const every: {
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
<A>(self: SortedSet<A>, predicate: Predicate<A>): boolean;
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
};

@@ -72,6 +75,6 @@ /**

export declare const filter: {
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>;
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>;
<A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>;
<A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>;
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>;
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -83,4 +86,4 @@ /**

export declare const flatMap: {
<B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>;
<A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>): SortedSet<B>;
<B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>;
};

@@ -92,4 +95,4 @@ /**

export declare const forEach: {
<A>(f: (a: A) => void): (self: SortedSet<A>) => void;
<A>(self: SortedSet<A>, f: (a: A) => void): void;
<A>(f: (a: A) => void): (self: SortedSet<A>) => void;
};

@@ -101,4 +104,4 @@ /**

export declare const has: {
<A>(value: A): (self: SortedSet<A>) => boolean;
<A>(self: SortedSet<A>, value: A): boolean;
<A>(value: A): (self: SortedSet<A>) => boolean;
};

@@ -110,4 +113,4 @@ /**

export declare const intersection: {
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
<A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>;
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -119,4 +122,4 @@ /**

export declare const isSubset: {
<A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean;
<A>(self: SortedSet<A>, that: SortedSet<A>): boolean;
<A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean;
};

@@ -128,4 +131,4 @@ /**

export declare const map: {
<B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>;
<B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B): SortedSet<B>;
<B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>;
};

@@ -137,6 +140,6 @@ /**

export declare const partition: {
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<B>];
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<A>];
<A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): readonly [SortedSet<A>, SortedSet<B>];
<A>(self: SortedSet<A>, predicate: Predicate<A>): readonly [SortedSet<A>, SortedSet<A>];
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<B>];
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<A>];
};

@@ -148,4 +151,4 @@ /**

export declare const remove: {
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
<A>(self: SortedSet<A>, value: A): SortedSet<A>;
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -162,4 +165,4 @@ /**

export declare const some: {
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
<A>(self: SortedSet<A>, predicate: Predicate<A>): boolean;
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean;
};

@@ -171,4 +174,4 @@ /**

export declare const toggle: {
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
<A>(self: SortedSet<A>, value: A): SortedSet<A>;
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -180,4 +183,4 @@ /**

export declare const union: {
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
<A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>;
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>;
};

@@ -184,0 +187,0 @@ /**

2

SortedSet.js

@@ -7,6 +7,6 @@ "use strict";

exports.values = exports.union = exports.toggle = exports.some = exports.size = exports.remove = exports.partition = exports.map = exports.make = exports.isSubset = exports.isSortedSet = exports.intersection = exports.has = exports.fromIterable = exports.forEach = exports.flatMap = exports.filter = exports.every = exports.empty = exports.difference = exports.add = void 0;
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Dual"));
var Equal = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Equal"));
var Hash = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/Hash"));
var RBT = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@effect/data/RedBlackTree"));
var Dual = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fp-ts/core/Function"));
function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }

@@ -13,0 +13,0 @@ function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }

16

src/Brand.ts

@@ -233,3 +233,9 @@ /**

[RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
of: (args) => pipe(either(args), Either.getOrThrow(identity)),
of: (args) =>
pipe(
either(args),
Either.match((e) => {
throw e
}, identity)
),
option: (args) => Option.fromEither(either(args)),

@@ -272,3 +278,9 @@ either,

[RefinedConstructorsTypeId]: RefinedConstructorsTypeId,
of: (args) => pipe(either(args), Either.getOrThrow(identity)),
of: (args) =>
pipe(
either(args),
Either.match((e) => {
throw e
}, identity)
),
option: (args) => Option.fromEither(either(args)),

@@ -275,0 +287,0 @@ either,

475

src/Chunk.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"

@@ -9,2 +8,3 @@ import * as Hash from "@effect/data/Hash"

import type { Either } from "@fp-ts/core/Either"
import * as Dual from "@fp-ts/core/Function"
import { identity, pipe } from "@fp-ts/core/Function"

@@ -451,7 +451,7 @@ import type { TypeLambda } from "@fp-ts/core/HKT"

export const get: {
(index: number): <A>(self: Chunk<A>) => Option<A>
<A>(self: Chunk<A>, index: number): Option<A>
(index: number): <A>(self: Chunk<A>) => Option<A>
} = Dual.dual<
<A>(self: Chunk<A>, index: number) => Option<A>,
(index: number) => <A>(self: Chunk<A>) => Option<A>
(index: number) => <A>(self: Chunk<A>) => Option<A>,
<A>(self: Chunk<A>, index: number) => Option<A>
>(2, (self, index) => self.get(index))

@@ -474,7 +474,7 @@

export const unsafeGet: {
(index: number): <A>(self: Chunk<A>) => A
<A>(self: Chunk<A>, index: number): A
(index: number): <A>(self: Chunk<A>) => A
} = Dual.dual<
<A>(self: Chunk<A>, index: number) => A,
(index: number) => <A>(self: Chunk<A>) => A
(index: number) => <A>(self: Chunk<A>) => A,
<A>(self: Chunk<A>, index: number) => A
>(2, (self, index) => self.unsafeGet(index))

@@ -489,7 +489,7 @@

export const append: {
<A2>(a: A2): <A>(self: Chunk<A>) => Chunk<A2 | A>
<A, A2>(self: Chunk<A>, a: A2): Chunk<A | A2>
<A2>(a: A2): <A>(self: Chunk<A>) => Chunk<A2 | A>
} = Dual.dual<
<A, A2>(self: Chunk<A>, a: A2) => Chunk<A | A2>,
<A2>(a: A2) => <A>(self: Chunk<A>) => Chunk<A | A2>
<A2>(a: A2) => <A>(self: Chunk<A>) => Chunk<A | A2>,
<A, A2>(self: Chunk<A>, a: A2) => Chunk<A | A2>
>(2, (self, a) => self.append(a))

@@ -504,7 +504,7 @@

export const prepend: {
<B>(elem: B): <A>(self: Chunk<A>) => Chunk<B | A>
<A, B>(self: Chunk<A>, elem: B): Chunk<A | B>
<B>(elem: B): <A>(self: Chunk<A>) => Chunk<B | A>
} = Dual.dual<
<A, B>(self: Chunk<A>, elem: B) => Chunk<A | B>,
<B>(elem: B) => <A>(self: Chunk<A>) => Chunk<A | B>
<B>(elem: B) => <A>(self: Chunk<A>) => Chunk<A | B>,
<A, B>(self: Chunk<A>, elem: B) => Chunk<A | B>
>(2, (self, elem) => self.prepend(elem))

@@ -519,7 +519,7 @@

export const take: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, n: number): Chunk<A>
(n: number): <A>(self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, n: number) => Chunk<A>,
(n: number) => <A>(self: Chunk<A>) => Chunk<A>
(n: number) => <A>(self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, n: number) => Chunk<A>
>(2, (self, n) => {

@@ -542,7 +542,7 @@ if (n <= 0) {

export const drop: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, n: number): Chunk<A>
(n: number): <A>(self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, n: number) => Chunk<A>,
(n: number) => <A>(self: Chunk<A>) => Chunk<A>
(n: number) => <A>(self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, n: number) => Chunk<A>
>(2, (self, n) => {

@@ -565,7 +565,7 @@ if (n <= 0) {

export const dropRight: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, n: number): Chunk<A>
(n: number): <A>(self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, n: number) => Chunk<A>,
(n: number) => <A>(self: Chunk<A>) => Chunk<A>
(n: number) => <A>(self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, n: number) => Chunk<A>
>(2, (self, n) => take(self, Math.max(0, self.length - n)))

@@ -580,7 +580,7 @@

export const dropWhile: {
<A>(f: (a: A) => boolean): (self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, f: (a: A) => boolean): Chunk<A>
<A>(f: (a: A) => boolean): (self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, f: (a: A) => boolean) => Chunk<A>,
<A>(f: (a: A) => boolean) => (self: Chunk<A>) => Chunk<A>
<A>(f: (a: A) => boolean) => (self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, f: (a: A) => boolean) => Chunk<A>
>(2, (self, f) => {

@@ -601,14 +601,14 @@ const arr = toReadonlyArray(self)

export const prependAllNonEmpty: {
<B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<B | A>
<B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<B | A>
<A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
<A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
<B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<A | B>
<B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<A | B>
} = Dual.dual<
{
<B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<A | B>
<B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<A | B>
},
{
<A, B>(self: Chunk<A>, that: NonEmptyChunk<B>): NonEmptyChunk<A | B>
<A, B>(self: NonEmptyChunk<A>, that: Chunk<B>): NonEmptyChunk<A | B>
},
{
<B>(that: NonEmptyChunk<B>): <A>(self: Chunk<A>) => NonEmptyChunk<A | B>
<B>(that: Chunk<B>): <A>(self: NonEmptyChunk<A>) => NonEmptyChunk<A | B>
}

@@ -624,7 +624,7 @@ >(2, (self, that) => that.concat(self) as any)

export const concat: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<B | A>
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<B | A>
} = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A | B>,
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<A | B>
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<A | B>,
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A | B>
>(2, (self, that) => self.concat(that))

@@ -639,7 +639,7 @@

export const correspondsTo: {
<A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean): (self: Chunk<A>) => boolean
<A, B>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => boolean): boolean
<A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean): (self: Chunk<A>) => boolean
} = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => boolean) => boolean,
<A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean) => (self: Chunk<A>) => boolean
<A, B>(that: Chunk<B>, f: (a: A, b: B) => boolean) => (self: Chunk<A>) => boolean,
<A, B>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => boolean) => boolean
>(3, (self, that, f) => {

@@ -661,7 +661,7 @@ if (self.length !== that.length) {

export const filterMap: {
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>): Chunk<B>
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>
} = Dual.dual<
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => Chunk<B>,
<A, B>(f: (a: A) => Option<B>) => (self: Iterable<A>) => Chunk<B>
<A, B>(f: (a: A) => Option<B>) => (self: Iterable<A>) => Chunk<B>,
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => Chunk<B>
>(2, (self, f) => unsafeFromArray(RA.filterMap(f)(self)))

@@ -676,14 +676,14 @@

export const filter: {
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
<C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): Chunk<B>
<B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): Chunk<B>
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
} = Dual.dual<
{
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
},
{
<C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): Chunk<B>
<B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): Chunk<B>
},
{
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => Chunk<B>
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => Chunk<B>
}

@@ -703,8 +703,8 @@ >(

export const filterMapWithIndex: {
<A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Chunk<B>
<A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>): Chunk<B>
<A, B>(f: (a: A, i: number) => Option<B>): (self: Iterable<A>) => Chunk<B>
} = Dual.dual<
<A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => Chunk<B>,
<A, B>(f: (a: A, i: number) => Option<B>) => (self: Iterable<A>) => Chunk<B>
>(2, (self, f) => unsafeFromArray(RA.filterMapWithIndex(f)(self)))
<A, B>(f: (a: A, i: number) => Option<B>) => (self: Iterable<A>) => Chunk<B>,
<A, B>(self: Iterable<A>, f: (a: A, i: number) => Option<B>) => Chunk<B>
>(2, (self, f) => unsafeFromArray(RA.filterMap(f)(self)))

@@ -718,7 +718,7 @@ /**

export const filterMapWhile: {
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>): Chunk<B>
<A, B>(f: (a: A) => Option<B>): (self: Iterable<A>) => Chunk<B>
} = Dual.dual<
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => Chunk<B>,
<A, B>(f: (a: A) => Option<B>) => (self: Iterable<A>) => Chunk<B>
<A, B>(f: (a: A) => Option<B>) => (self: Iterable<A>) => Chunk<B>,
<A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => Chunk<B>
>(2, <A, B>(self: Iterable<A>, f: (a: A) => Option<B>) => {

@@ -744,7 +744,7 @@ const res: Array<B> = []

export const elem: {
<B>(b: B): <A>(self: Chunk<A>) => boolean
<A, B>(self: Chunk<A>, b: B): boolean
<B>(b: B): <A>(self: Chunk<A>) => boolean
} = Dual.dual<
<A, B>(self: Chunk<A>, b: B) => boolean,
<B>(b: B) => <A>(self: Chunk<A>) => boolean
<B>(b: B) => <A>(self: Chunk<A>) => boolean,
<A, B>(self: Chunk<A>, b: B) => boolean
>(2, (self, b) => pipe(toReadonlyArray(self), RA.contains(Equal.equivalence())(b)))

@@ -785,7 +785,7 @@

export const some: {
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean
<A>(self: Chunk<A>, f: Predicate<A>): boolean
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean
} = Dual.dual<
<A>(self: Chunk<A>, f: Predicate<A>) => boolean,
<A>(f: Predicate<A>) => (self: Chunk<A>) => boolean
<A>(f: Predicate<A>) => (self: Chunk<A>) => boolean,
<A>(self: Chunk<A>, f: Predicate<A>) => boolean
>(2, (self, f) => toReadonlyArray(self).findIndex((v) => f(v)) !== -1)

@@ -800,7 +800,7 @@

export const every: {
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean
<A>(self: Chunk<A>, f: Predicate<A>): boolean
<A>(f: Predicate<A>): (self: Chunk<A>) => boolean
} = Dual.dual<
<A>(self: Chunk<A>, f: Predicate<A>) => boolean,
<A>(f: Predicate<A>) => (self: Chunk<A>) => boolean
<A>(f: Predicate<A>) => (self: Chunk<A>) => boolean,
<A>(self: Chunk<A>, f: Predicate<A>) => boolean
>(2, (self, f) => toReadonlyArray(self).every((v) => f(v)))

@@ -814,10 +814,15 @@

*/
export const findFirst = Dual.dual<
export const findFirst: {
<A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
<A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<A>
<A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>
<A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>
} = Dual.dual<
{
<A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
<A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<A>
},
{
<A, B extends A>(self: Chunk<A>, refinement: Refinement<A, B>): Option<B>
<A>(self: Chunk<A>, predicate: Predicate<A>): Option<A>
},
{
<A, B extends A>(refinement: Refinement<A, B>): (self: Chunk<A>) => Option<B>
<A>(predicate: Predicate<A>): (self: Chunk<A>) => Option<A>
}

@@ -832,5 +837,8 @@ >(2, <A>(self: Chunk<A>, predicate: Predicate<A>) => RA.findFirst(predicate)(toReadonlyArray(self)))

*/
export const findFirstIndex = Dual.dual<
<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>,
<A>(f: Predicate<A>) => (self: Chunk<A>) => Option<number>
export const findFirstIndex: {
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<number>
<A>(self: Chunk<A>, f: Predicate<A>): Option<number>
} = Dual.dual<
<A>(f: Predicate<A>) => (self: Chunk<A>) => Option<number>,
<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>
>(2, (self, f) => RA.findFirstIndex(f)(toReadonlyArray(self)))

@@ -844,5 +852,8 @@

*/
export const findLastIndex = Dual.dual<
<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>,
<A>(f: Predicate<A>) => (self: Chunk<A>) => Option<number>
export const findLastIndex: {
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<number>
<A>(self: Chunk<A>, f: Predicate<A>): Option<number>
} = Dual.dual<
<A>(f: Predicate<A>) => (self: Chunk<A>) => Option<number>,
<A>(self: Chunk<A>, f: Predicate<A>) => Option<number>
>(2, (self, f) => RA.findLastIndex(f)(toReadonlyArray(self)))

@@ -856,10 +867,15 @@

*/
export const findLast = Dual.dual<
export const findLast: {
<A, B extends A>(f: Refinement<A, B>): (self: Chunk<A>) => Option<B>
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<A>
<A, B extends A>(self: Chunk<A>, f: Refinement<A, B>): Option<B>
<A>(self: Chunk<A>, f: Predicate<A>): Option<A>
} = Dual.dual<
{
<A, B extends A>(f: Refinement<A, B>): (self: Chunk<A>) => Option<B>
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<A>
},
{
<A, B extends A>(self: Chunk<A>, f: Refinement<A, B>): Option<B>
<A>(self: Chunk<A>, f: Predicate<A>): Option<A>
},
{
<A, B extends A>(f: Refinement<A, B>): (self: Chunk<A>) => Option<B>
<A>(f: Predicate<A>): (self: Chunk<A>) => Option<A>
}

@@ -874,5 +890,8 @@ >(2, <A>(self: Chunk<A>, f: Predicate<A>) => RA.findLast(f)(toReadonlyArray(self)))

*/
export const flatMap = Dual.dual<
<A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>) => Chunk<B>,
<A, B>(f: (a: A) => Chunk<B>) => (self: Chunk<A>) => Chunk<B>
export const flatMap: {
<A, B>(f: (a: A) => Chunk<B>): (self: Chunk<A>) => Chunk<B>
<A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>): Chunk<B>
} = Dual.dual<
<A, B>(f: (a: A) => Chunk<B>) => (self: Chunk<A>) => Chunk<B>,
<A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>) => Chunk<B>
>(2, <A, B>(self: Chunk<A>, f: (a: A) => Chunk<B>) => {

@@ -903,5 +922,8 @@ if (self.backing._tag === "ISingleton") {

*/
export const forEach = Dual.dual<
<A>(self: Chunk<A>, f: (a: A) => void) => void,
<A>(f: (a: A) => void) => (self: Chunk<A>) => void
export const forEach: {
<A>(f: (a: A) => void): (self: Chunk<A>) => void
<A>(self: Chunk<A>, f: (a: A) => void): void
} = Dual.dual<
<A>(f: (a: A) => void) => (self: Chunk<A>) => void,
<A>(self: Chunk<A>, f: (a: A) => void) => void
>(2, (self, f) => self.forEach(f))

@@ -915,5 +937,8 @@

*/
export const chunksOf = Dual.dual<
<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>,
(n: number) => <A>(self: Chunk<A>) => Chunk<Chunk<A>>
export const chunksOf: {
(n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>
<A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>
} = Dual.dual<
(n: number) => <A>(self: Chunk<A>) => Chunk<Chunk<A>>,
<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>
>(2, <A>(self: Chunk<A>, n: number) => {

@@ -951,5 +976,8 @@ const gr: Array<Chunk<A>> = []

*/
export const intersection = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A & B>,
<A>(that: Chunk<A>) => <B>(self: Chunk<B>) => Chunk<A & B>
export const intersection: {
<A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A & B>
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A & B>
} = Dual.dual<
<A>(that: Chunk<A>) => <B>(self: Chunk<B>) => Chunk<A & B>,
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A & B>
>(2, (self, that) =>

@@ -984,5 +1012,8 @@ pipe(

*/
export const reduce = Dual.dual<
<A, B>(self: Chunk<A>, b: B, f: (s: B, a: A) => B) => B,
<A, B>(b: B, f: (s: B, a: A) => B) => (self: Chunk<A>) => B
export const reduce: {
<A, B>(b: B, f: (s: B, a: A) => B): (self: Chunk<A>) => B
<A, B>(self: Chunk<A>, b: B, f: (s: B, a: A) => B): B
} = Dual.dual<
<A, B>(b: B, f: (s: B, a: A) => B) => (self: Chunk<A>) => B,
<A, B>(self: Chunk<A>, b: B, f: (s: B, a: A) => B) => B
>(3, (self, b, f) => pipe(toReadonlyArray(self), RA.reduce(b, f)))

@@ -996,6 +1027,9 @@

*/
export const reduceWithIndex = Dual.dual<
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B,
<B, A>(b: B, f: (b: B, a: A, i: number) => B) => (self: Chunk<A>) => B
>(3, (self, b, f) => pipe(toReadonlyArray(self), RA.reduceWithIndex(b, f)))
export const reduceWithIndex: {
<B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B
} = Dual.dual<
<B, A>(b: B, f: (b: B, a: A, i: number) => B) => (self: Chunk<A>) => B,
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B
>(3, (self, b, f) => pipe(toReadonlyArray(self), RA.reduce(b, f)))

@@ -1008,5 +1042,8 @@ /**

*/
export const reduceRight = Dual.dual<
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A) => B) => B,
<B, A>(b: B, f: (b: B, a: A) => B) => (self: Chunk<A>) => B
export const reduceRight: {
<B, A>(b: B, f: (b: B, a: A) => B): (self: Chunk<A>) => B
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A) => B): B
} = Dual.dual<
<B, A>(b: B, f: (b: B, a: A) => B) => (self: Chunk<A>) => B,
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A) => B) => B
>(3, (self, b, f) => pipe(toReadonlyArray(self), RA.reduceRight(b, (b, a) => f(b, a))))

@@ -1020,6 +1057,9 @@

*/
export const reduceRightWithIndex = Dual.dual<
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B,
<B, A>(b: B, f: (b: B, a: A, i: number) => B) => (self: Chunk<A>) => B
>(3, (self, b, f) => pipe(toReadonlyArray(self), RA.reduceRightWithIndex(b, f)))
export const reduceRightWithIndex: {
<B, A>(b: B, f: (b: B, a: A, i: number) => B): (self: Chunk<A>) => B
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B): B
} = Dual.dual<
<B, A>(b: B, f: (b: B, a: A, i: number) => B) => (self: Chunk<A>) => B,
<A, B>(self: Chunk<A>, b: B, f: (b: B, a: A, i: number) => B) => B
>(3, (self, b, f) => pipe(toReadonlyArray(self), RA.reduceRight(b, f)))

@@ -1033,7 +1073,7 @@ /**

export const join: {
(sep: string): (self: Chunk<string>) => string
(self: Chunk<string>, sep: string): string
(sep: string): (self: Chunk<string>) => string
} = Dual.dual<
(self: Chunk<string>, sep: string) => string,
(sep: string) => (self: Chunk<string>) => string
(sep: string) => (self: Chunk<string>) => string,
(self: Chunk<string>, sep: string) => string
>(2, (self, sep) => reduce(self, "", (s, a) => (s.length > 0 ? `${s}${sep}${a}` : a)))

@@ -1076,8 +1116,8 @@

export const makeBy: {
<A>(f: (i: number) => A): (n: number) => NonEmptyChunk<A>
<A>(n: number, f: (i: number) => A): NonEmptyChunk<A>
<A>(f: (i: number) => A): (n: number) => NonEmptyChunk<A>
} = Dual.dual<
<A>(n: number, f: (i: number) => A) => NonEmptyChunk<A>,
<A>(f: (i: number) => A) => (n: number) => NonEmptyChunk<A>
>(2, (n, f) => make(...RA.makeBy(f)(n)))
<A>(f: (i: number) => A) => (n: number) => NonEmptyChunk<A>,
<A>(n: number, f: (i: number) => A) => NonEmptyChunk<A>
>(2, (n, f) => make(...RA.makeBy(n, f)))

@@ -1091,7 +1131,7 @@ /**

export const map: {
<A, B>(f: (a: A) => B): (self: Chunk<A>) => Chunk<B>
<A, B>(self: Chunk<A>, f: (a: A) => B): Chunk<B>
<A, B>(f: (a: A) => B): (self: Chunk<A>) => Chunk<B>
} = Dual.dual<
<A, B>(self: Chunk<A>, f: (a: A) => B) => Chunk<B>,
<A, B>(f: (a: A) => B) => (self: Chunk<A>) => Chunk<B>
<A, B>(f: (a: A) => B) => (self: Chunk<A>) => Chunk<B>,
<A, B>(self: Chunk<A>, f: (a: A) => B) => Chunk<B>
>(2, (self, f) => self.map(f))

@@ -1106,11 +1146,11 @@

export const mapWithIndex: {
<A, B>(f: (a: A, i: number) => B): (self: Chunk<A>) => Chunk<B>
<A, B>(self: Chunk<A>, f: (a: A, i: number) => B): Chunk<B>
<A, B>(f: (a: A, i: number) => B): (self: Chunk<A>) => Chunk<B>
} = Dual.dual<
<A, B>(self: Chunk<A>, f: (a: A, i: number) => B) => Chunk<B>,
<A, B>(f: (a: A, i: number) => B) => (self: Chunk<A>) => Chunk<B>
<A, B>(f: (a: A, i: number) => B) => (self: Chunk<A>) => Chunk<B>,
<A, B>(self: Chunk<A>, f: (a: A, i: number) => B) => Chunk<B>
>(2, (self, f) =>
self.backing._tag === "ISingleton" ?
of(f(self.backing.a, 0)) :
unsafeFromArray(pipe(toReadonlyArray(self), RA.mapWithIndex(f))))
unsafeFromArray(pipe(toReadonlyArray(self), RA.map(f))))

@@ -1124,7 +1164,7 @@ /**

export const mapAccum: {
<S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk<A>) => readonly [S, Chunk<B>]
<S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]): readonly [S, Chunk<B>]
<S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: Chunk<A>) => readonly [S, Chunk<B>]
} = Dual.dual<
<S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]) => readonly [S, Chunk<B>],
<S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]) => (self: Chunk<A>) => readonly [S, Chunk<B>]
<S, A, B>(s: S, f: (s: S, a: A) => readonly [S, B]) => (self: Chunk<A>) => readonly [S, Chunk<B>],
<S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]) => readonly [S, Chunk<B>]
>(3, <S, A, B>(self: Chunk<A>, s: S, f: (s: S, a: A) => readonly [S, B]) => {

@@ -1149,17 +1189,20 @@ let s1 = s

<C extends A, B extends A, A = C>(
refinement: (a: A, i: number) => a is B
): (self: Chunk<C>) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(predicate: (a: A, i: number) => boolean): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>]
<C extends A, B extends A, A = C>(
self: Chunk<C>,
refinement: (a: A, i: number) => a is B
): readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(
self: Chunk<B>,
predicate: (a: A, i: number) => boolean
): readonly [Chunk<B>, Chunk<B>]
<C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (
self: Chunk<C>
) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(predicate: (a: A, i: number) => boolean): (
self: Chunk<B>
) => readonly [Chunk<B>, Chunk<B>]
<B extends A, A = B>(self: Chunk<B>, predicate: (a: A, i: number) => boolean): readonly [Chunk<B>, Chunk<B>]
} = Dual.dual<
{
<C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (
self: Chunk<C>
) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(predicate: (a: A, i: number) => boolean): (
self: Chunk<B>
) => readonly [Chunk<B>, Chunk<B>]
},
{
<C extends A, B extends A, A = C>(

@@ -1173,10 +1216,2 @@ self: Chunk<C>,

): readonly [Chunk<B>, Chunk<B>]
},
{
<C extends A, B extends A, A = C>(refinement: (a: A, i: number) => a is B): (
self: Chunk<C>
) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(predicate: (a: A, i: number) => boolean): (
self: Chunk<B>
) => readonly [Chunk<B>, Chunk<B>]
}

@@ -1186,3 +1221,3 @@ >(2, <B extends A, A = B>(self: Chunk<B>, f: (a: A, i: number) => boolean) =>

toReadonlyArray(self),
RA.partitionWithIndex(f),
RA.partition(f),
([l, r]) => [unsafeFromArray(l), unsafeFromArray(r)] as const

@@ -1198,18 +1233,16 @@ ))

export const partition: {
<C extends A, B extends A, A = C>(
self: Chunk<C>,
refinement: Refinement<A, B>
): readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(
self: Chunk<B>,
predicate: Predicate<A>
): readonly [Chunk<B>, Chunk<B>]
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (
self: Chunk<C>
) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(
predicate: Predicate<A>
): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>]
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (self: Chunk<C>) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(predicate: Predicate<A>): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>]
<C extends A, B extends A, A = C>(self: Chunk<C>, refinement: Refinement<A, B>): readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>): readonly [Chunk<B>, Chunk<B>]
} = Dual.dual<
{
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (
self: Chunk<C>
) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(
predicate: Predicate<A>
): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>]
},
{
<C extends A, B extends A, A = C>(

@@ -1223,10 +1256,2 @@ self: Chunk<C>,

): readonly [Chunk<B>, Chunk<B>]
},
{
<C extends A, B extends A, A = C>(refinement: Refinement<A, B>): (
self: Chunk<C>
) => readonly [Chunk<C>, Chunk<B>]
<B extends A, A = B>(
predicate: Predicate<A>
): (self: Chunk<B>) => readonly [Chunk<B>, Chunk<B>]
}

@@ -1247,7 +1272,7 @@ >(2, <B extends A, A = B>(self: Chunk<B>, predicate: Predicate<A>) =>

export const partitionMap: {
<A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => readonly [Chunk<B>, Chunk<C>]
<A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>): readonly [Chunk<B>, Chunk<C>]
<A, B, C>(f: (a: A) => Either<B, C>): (self: Chunk<A>) => readonly [Chunk<B>, Chunk<C>]
} = Dual.dual<
<A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>) => readonly [Chunk<B>, Chunk<C>],
<A, B, C>(f: (a: A) => Either<B, C>) => (self: Chunk<A>) => readonly [Chunk<B>, Chunk<C>]
<A, B, C>(f: (a: A) => Either<B, C>) => (self: Chunk<A>) => readonly [Chunk<B>, Chunk<C>],
<A, B, C>(self: Chunk<A>, f: (a: A) => Either<B, C>) => readonly [Chunk<B>, Chunk<C>]
>(2, (self, f) =>

@@ -1307,7 +1332,7 @@ pipe(

export const sort: {
<B>(O: Order<B>): <A extends B>(self: Chunk<A>) => Chunk<A>
<A extends B, B>(self: Chunk<A>, O: Order<B>): Chunk<A>
<B>(O: Order<B>): <A extends B>(self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A extends B, B>(self: Chunk<A>, O: Order<B>) => Chunk<A>,
<B>(O: Order<B>) => <A extends B>(self: Chunk<A>) => Chunk<A>
<B>(O: Order<B>) => <A extends B>(self: Chunk<A>) => Chunk<A>,
<A extends B, B>(self: Chunk<A>, O: Order<B>) => Chunk<A>
>(2, (self, O) => pipe(toReadonlyArray(self), RA.sort(O), unsafeFromArray))

@@ -1322,7 +1347,7 @@

export const splitAt: {
(n: number): <A>(self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>]
<A>(self: Chunk<A>, n: number): readonly [Chunk<A>, Chunk<A>]
(n: number): <A>(self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>]
} = Dual.dual<
<A>(self: Chunk<A>, n: number) => readonly [Chunk<A>, Chunk<A>],
(n: number) => <A>(self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>]
(n: number) => <A>(self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>],
<A>(self: Chunk<A>, n: number) => readonly [Chunk<A>, Chunk<A>]
>(2, (self, n) => [take(n)(self), drop(n)(self)])

@@ -1337,7 +1362,7 @@

export const split: {
(n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>
<A>(self: Chunk<A>, n: number): Chunk<Chunk<A>>
(n: number): <A>(self: Chunk<A>) => Chunk<Chunk<A>>
} = Dual.dual<
<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>,
(n: number) => <A>(self: Chunk<A>) => Chunk<Chunk<A>>
(n: number) => <A>(self: Chunk<A>) => Chunk<Chunk<A>>,
<A>(self: Chunk<A>, n: number) => Chunk<Chunk<A>>
>(2, <A>(self: Chunk<A>, n: number) => {

@@ -1375,7 +1400,7 @@ const length = self.length

export const splitWhere: {
<A>(f: Predicate<A>): (self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>]
<A>(self: Chunk<A>, f: Predicate<A>): readonly [Chunk<A>, Chunk<A>]
<A>(f: Predicate<A>): (self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>]
} = Dual.dual<
<A>(self: Chunk<A>, f: Predicate<A>) => readonly [Chunk<A>, Chunk<A>],
<A>(f: Predicate<A>) => (self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>]
<A>(f: Predicate<A>) => (self: Chunk<A>) => readonly [Chunk<A>, Chunk<A>],
<A>(self: Chunk<A>, f: Predicate<A>) => readonly [Chunk<A>, Chunk<A>]
>(2, (self, f) => {

@@ -1408,7 +1433,7 @@ let i = 0

export const takeRight: {
(n: number): <A>(self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, n: number): Chunk<A>
(n: number): <A>(self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, n: number) => Chunk<A>,
(n: number) => <A>(self: Chunk<A>) => Chunk<A>
(n: number) => <A>(self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, n: number) => Chunk<A>
>(2, (self, n) => drop(self, self.length - n))

@@ -1423,7 +1448,7 @@

export const takeWhile: {
<A>(f: Predicate<A>): (self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, f: Predicate<A>): Chunk<A>
<A>(f: Predicate<A>): (self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, f: Predicate<A>) => Chunk<A>,
<A>(f: Predicate<A>) => (self: Chunk<A>) => Chunk<A>
<A>(f: Predicate<A>) => (self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, f: Predicate<A>) => Chunk<A>
>(2, <A>(self: Chunk<A>, f: Predicate<A>) => {

@@ -1470,7 +1495,7 @@ const res: Array<A> = []

export const union: {
<A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<A | B>
<A>(that: Chunk<A>): <B>(self: Chunk<B>) => Chunk<A | B>
} = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A | B>,
<A>(that: Chunk<A>) => <B>(self: Chunk<B>) => Chunk<A | B>
<A>(that: Chunk<A>) => <B>(self: Chunk<B>) => Chunk<A | B>,
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<A | B>
>(2, <A, B>(self: Chunk<A>, that: Chunk<B>) =>

@@ -1531,7 +1556,7 @@ unsafeFromArray(

export const zip: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<readonly [A, B]>
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>
} = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [A, B]>,
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<readonly [A, B]>
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<readonly [A, B]>,
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [A, B]>
>(2, (self, that) => zipWith(self, that, (a, b) => [a, b]))

@@ -1546,7 +1571,7 @@

export const zipWith: {
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C): Chunk<C>
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>
} = Dual.dual<
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C) => Chunk<C>,
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C) => (self: Chunk<A>) => Chunk<C>
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C) => (self: Chunk<A>) => Chunk<C>,
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C) => Chunk<C>
>(3, (self, that, f) => {

@@ -1568,7 +1593,7 @@ const selfA = toReadonlyArray(self)

export const zipAll: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [Option<A>, Option<B>]>
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<readonly [Option<A>, Option<B>]>
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [Option<A>, Option<B>]>
} = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [Option<A>, Option<B>]>,
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<readonly [Option<A>, Option<B>]>
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<readonly [Option<A>, Option<B>]>,
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [Option<A>, Option<B>]>
>(2, (self, that) =>

@@ -1595,3 +1620,2 @@ zipAllWith(

<A, B, C, D, E>(
self: Chunk<A>,
that: Chunk<B>,

@@ -1601,4 +1625,5 @@ f: (a: A, b: B) => C,

right: (b: B) => E
): Chunk<C | D | E>
): (self: Chunk<A>) => Chunk<C | D | E>
<A, B, C, D, E>(
self: Chunk<A>,
that: Chunk<B>,

@@ -1608,6 +1633,5 @@ f: (a: A, b: B) => C,

right: (b: B) => E
): (self: Chunk<A>) => Chunk<C | D | E>
): Chunk<C | D | E>
} = Dual.dual<
<A, B, C, D, E>(
self: Chunk<A>,
that: Chunk<B>,

@@ -1617,4 +1641,5 @@ f: (a: A, b: B) => C,

right: (b: B) => E
) => Chunk<C | D | E>,
) => (self: Chunk<A>) => Chunk<C | D | E>,
<A, B, C, D, E>(
self: Chunk<A>,
that: Chunk<B>,

@@ -1624,3 +1649,3 @@ f: (a: A, b: B) => C,

right: (b: B) => E
) => (self: Chunk<A>) => Chunk<C | D | E>
) => Chunk<C | D | E>
>(5, <A, B, C, D, E>(

@@ -1671,7 +1696,7 @@ self: Chunk<A>,

export const crossWith: {
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C): Chunk<C>
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C): (self: Chunk<A>) => Chunk<C>
} = Dual.dual<
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C) => Chunk<C>,
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C) => (self: Chunk<A>) => Chunk<C>
<A, B, C>(that: Chunk<B>, f: (a: A, b: B) => C) => (self: Chunk<A>) => Chunk<C>,
<A, B, C>(self: Chunk<A>, that: Chunk<B>, f: (a: A, b: B) => C) => Chunk<C>
>(3, (self, that, f) => flatMap(self, (a) => pipe(that, map((b) => f(a, b)))))

@@ -1686,7 +1711,7 @@

export const cross: {
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>
<A, B>(self: Chunk<A>, that: Chunk<B>): Chunk<readonly [A, B]>
<B>(that: Chunk<B>): <A>(self: Chunk<A>) => Chunk<readonly [A, B]>
} = Dual.dual<
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [A, B]>,
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<readonly [A, B]>
<B>(that: Chunk<B>) => <A>(self: Chunk<A>) => Chunk<readonly [A, B]>,
<A, B>(self: Chunk<A>, that: Chunk<B>) => Chunk<readonly [A, B]>
>(2, (self, that) => crossWith(self, that, (a, b) => [a, b]))

@@ -1711,7 +1736,7 @@

export const zipWithIndexOffset: {
(offset: number): <A>(self: Chunk<A>) => Chunk<[A, number]>
<A>(self: Chunk<A>, offset: number): Chunk<[A, number]>
(offset: number): <A>(self: Chunk<A>) => Chunk<[A, number]>
} = Dual.dual<
<A>(self: Chunk<A>, offset: number) => Chunk<[A, number]>,
(offset: number) => <A>(self: Chunk<A>) => Chunk<[A, number]>
(offset: number) => <A>(self: Chunk<A>) => Chunk<[A, number]>,
<A>(self: Chunk<A>, offset: number) => Chunk<[A, number]>
>(2, <A>(self: Chunk<A>, offset: number) => {

@@ -1737,7 +1762,7 @@ const iterator = self[Symbol.iterator]()

export const remove: {
(i: number): <A>(self: Chunk<A>) => Chunk<A>
<A>(self: Chunk<A>, i: number): Chunk<A>
(i: number): <A>(self: Chunk<A>) => Chunk<A>
} = Dual.dual<
<A>(self: Chunk<A>, i: number) => Chunk<A>,
(i: number) => <A>(self: Chunk<A>) => Chunk<A>
(i: number) => <A>(self: Chunk<A>) => Chunk<A>,
<A>(self: Chunk<A>, i: number) => Chunk<A>
>(2, (self, i) => pipe(self, toReadonlyArray, RA.remove(i), unsafeFromArray))

@@ -1753,7 +1778,7 @@

export const replace: {
<B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A>
<A, B>(self: Chunk<A>, i: number, b: B): Chunk<B | A>
<B>(i: number, b: B): <A>(self: Chunk<A>) => Chunk<B | A>
} = Dual.dual<
<A, B>(self: Chunk<A>, i: number, b: B) => Chunk<B | A>,
<B>(i: number, b: B) => <A>(self: Chunk<A>) => Chunk<B | A>
<B>(i: number, b: B) => <A>(self: Chunk<A>) => Chunk<B | A>,
<A, B>(self: Chunk<A>, i: number, b: B) => Chunk<B | A>
>(3, (self, i, b) => modify(self, i, () => b))

@@ -1766,7 +1791,7 @@

export const replaceOption: {
<B>(i: number, b: B): <A>(self: Chunk<A>) => Option<Chunk<B | A>>
<A, B>(self: Chunk<A>, i: number, b: B): Option<Chunk<B | A>>
<B>(i: number, b: B): <A>(self: Chunk<A>) => Option<Chunk<B | A>>
} = Dual.dual<
<A, B>(self: Chunk<A>, i: number, b: B) => Option<Chunk<B | A>>,
<B>(i: number, b: B) => <A>(self: Chunk<A>) => Option<Chunk<B | A>>
<B>(i: number, b: B) => <A>(self: Chunk<A>) => Option<Chunk<B | A>>,
<A, B>(self: Chunk<A>, i: number, b: B) => Option<Chunk<B | A>>
>(3, (self, i, b) => modifyOption(self, i, () => b))

@@ -1782,7 +1807,7 @@

export const modify: {
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B>
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Chunk<A | B>
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Chunk<A | B>
} = Dual.dual<
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B) => Chunk<A | B>,
<A, B>(i: number, f: (a: A) => B) => (self: Chunk<A>) => Chunk<A | B>
<A, B>(i: number, f: (a: A) => B) => (self: Chunk<A>) => Chunk<A | B>,
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B) => Chunk<A | B>
>(3, (self, i, f) => pipe(modifyOption(self, i, f), O.getOrElse(() => self)))

@@ -1795,7 +1820,7 @@

export const modifyOption: {
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Option<Chunk<A | B>>
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B): Option<Chunk<A | B>>
<A, B>(i: number, f: (a: A) => B): (self: Chunk<A>) => Option<Chunk<A | B>>
} = Dual.dual<
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B) => Option<Chunk<A | B>>,
<A, B>(i: number, f: (a: A) => B) => (self: Chunk<A>) => Option<Chunk<A | B>>
<A, B>(i: number, f: (a: A) => B) => (self: Chunk<A>) => Option<Chunk<A | B>>,
<A, B>(self: Chunk<A>, i: number, f: (a: A) => B) => Option<Chunk<A | B>>
>(3, (self, i, f) => pipe(self, toReadonlyArray, RA.modifyOption(i, f), O.map(unsafeFromArray)))

@@ -1802,0 +1827,0 @@

29

src/Context.ts

@@ -101,11 +101,11 @@ /**

export const add: {
<T extends Tag<any>>(
tag: T,
service: Tag.Service<T>
): <Services>(self: Context<Services>) => Context<Tag.Service<T> | Services>
<Services, T extends Tag<any>>(
self: Context<Services>,
tag: T,
tag: Tag<T>,
service: Tag.Service<T>
): Context<Services | Tag.Service<T>>
<T extends Tag<any>>(
tag: T,
service: Tag.Service<T>
): <Services>(self: Context<Services>) => Context<Tag.Service<T> | Services>
} = C.add

@@ -118,9 +118,4 @@

export const get: {
<Services, T extends Tags<Services>>(
self: Context<Services>,
tag: T
): T extends Tag<infer S> ? S : never
<Services, T extends Tags<Services>>(
tag: T
): (self: Context<Services>) => T extends Tag<infer S> ? S : never
<Services, T extends Tags<Services>>(tag: T): (self: Context<Services>) => T extends Tag<infer S> ? S : never
<Services, T extends Tags<Services>>(self: Context<Services>, tag: T): T extends Tag<infer S> ? S : never
} = C.get

@@ -133,4 +128,4 @@

export const unsafeGet: {
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => S
<Services, S>(self: Context<Services>, tag: Tag<S>): S
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => S
} = C.unsafeGet

@@ -143,4 +138,4 @@

export const getOption: {
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => Option<S>
<Services, S>(self: Context<Services>, tag: Tag<S>): Option<S>
<S>(tag: Tag<S>): <Services>(self: Context<Services>) => Option<S>
} = C.getOption

@@ -153,4 +148,4 @@

export const merge: {
<R1>(that: Context<R1>): <Services>(self: Context<Services>) => Context<R1 | Services>
<Services, R1>(self: Context<Services>, that: Context<R1>): Context<Services | R1>
<R1>(that: Context<R1>): <Services>(self: Context<Services>) => Context<R1 | Services>
} = C.merge

@@ -164,4 +159,2 @@

...tags: S
) => (
self: Context<Services>
) => Context<{ [k in keyof S]: Tag.Service<S[k]> }[number]> = C.prune
) => (self: Context<Services>) => Context<{ [k in keyof S]: Tag.Service<S[k]> }[number]> = C.prune

58

src/Differ.ts

@@ -11,3 +11,2 @@ /**

import type { OrPatch } from "@effect/data/Differ/OrPatch"
import * as Dual from "@effect/data/Dual"
import type { HashMap } from "@effect/data/HashMap"

@@ -17,2 +16,3 @@ import type { HashSet } from "@effect/data/HashSet"

import type { Either } from "@fp-ts/core/Either"
import * as Dual from "@fp-ts/core/Function"

@@ -97,7 +97,7 @@ const TypeId: unique symbol = D.DifferTypeId as TypeId

export const diff: {
<Value>(oldValue: Value, newValue: Value): <Patch>(differ: Differ<Value, Patch>) => Patch
<Value, Patch>(differ: Differ<Value, Patch>, oldValue: Value, newValue: Value): Patch
<Value>(oldValue: Value, newValue: Value): <Patch>(differ: Differ<Value, Patch>) => Patch
} = Dual.dual<
<Value, Patch>(differ: Differ<Value, Patch>, oldValue: Value, newValue: Value) => Patch,
<Value>(oldValue: Value, newValue: Value) => <Patch>(differ: Differ<Value, Patch>) => Patch
<Value>(oldValue: Value, newValue: Value) => <Patch>(differ: Differ<Value, Patch>) => Patch,
<Value, Patch>(differ: Differ<Value, Patch>, oldValue: Value, newValue: Value) => Patch
>(3, (self, oldValue, newValue) => self.diff(oldValue, newValue))

@@ -116,7 +116,7 @@

export const combine: {
<Patch>(first: Patch, second: Patch): <Value>(self: Differ<Value, Patch>) => Patch
<Value, Patch>(self: Differ<Value, Patch>, first: Patch, second: Patch): Patch
<Patch>(first: Patch, second: Patch): <Value>(self: Differ<Value, Patch>) => Patch
} = Dual.dual<
<Value, Patch>(self: Differ<Value, Patch>, first: Patch, second: Patch) => Patch,
<Patch>(first: Patch, second: Patch) => <Value>(self: Differ<Value, Patch>) => Patch
<Patch>(first: Patch, second: Patch) => <Value>(self: Differ<Value, Patch>) => Patch,
<Value, Patch>(self: Differ<Value, Patch>, first: Patch, second: Patch) => Patch
>(3, (self, first, second) => self.combine(first, second))

@@ -132,7 +132,7 @@

export const patch: {
<Patch, Value>(patch: Patch, oldValue: Value): (self: Differ<Value, Patch>) => Value
<Patch, Value>(self: Differ<Value, Patch>, patch: Patch, oldValue: Value): Value
<Patch, Value>(patch: Patch, oldValue: Value): (self: Differ<Value, Patch>) => Value
} = Dual.dual<
<Patch, Value>(self: Differ<Value, Patch>, patch: Patch, oldValue: Value) => Value,
<Patch, Value>(patch: Patch, oldValue: Value) => (self: Differ<Value, Patch>) => Value
<Patch, Value>(patch: Patch, oldValue: Value) => (self: Differ<Value, Patch>) => Value,
<Patch, Value>(self: Differ<Value, Patch>, patch: Patch, oldValue: Value) => Value
>(3, (self, patch, oldValue) => self.patch(patch, oldValue))

@@ -146,8 +146,10 @@

*/
export const make: <Value, Patch>(params: {
readonly empty: Patch
readonly diff: (oldValue: Value, newValue: Value) => Patch
readonly combine: (first: Patch, second: Patch) => Patch
readonly patch: (patch: Patch, oldValue: Value) => Value
}) => Differ<Value, Patch> = D.make
export const make: <Value, Patch>(
params: {
readonly empty: Patch
readonly diff: (oldValue: Value, newValue: Value) => Patch
readonly combine: (first: Patch, second: Patch) => Patch
readonly patch: (patch: Patch, oldValue: Value) => Value
}
) => Differ<Value, Patch> = D.make

@@ -200,2 +202,5 @@ /**

export const orElseResult: {
<Value2, Patch2>(
that: Differ<Value2, Patch2>
): <Value, Patch>(self: Differ<Value, Patch>) => Differ<Either<Value, Value2>, OrPatch<Value, Value2, Patch, Patch2>>
<Value, Patch, Value2, Patch2>(

@@ -205,7 +210,2 @@ self: Differ<Value, Patch>,

): Differ<Either<Value, Value2>, OrPatch<Value, Value2, Patch, Patch2>>
<Value2, Patch2>(
that: Differ<Value2, Patch2>
): <Value, Patch>(
self: Differ<Value, Patch>
) => Differ<Either<Value, Value2>, OrPatch<Value, Value2, Patch, Patch2>>
} = D.orElseResult

@@ -221,2 +221,6 @@

export const transform: {
<Value, Value2>(
f: (value: Value) => Value2,
g: (value: Value2) => Value
): <Patch>(self: Differ<Value, Patch>) => Differ<Value2, Patch>
<Value, Patch, Value2>(

@@ -227,6 +231,2 @@ self: Differ<Value, Patch>,

): Differ<Value2, Patch>
<Value, Value2>(
f: (value: Value) => Value2,
g: (value: Value2) => Value
): <Patch>(self: Differ<Value, Patch>) => Differ<Value2, Patch>
} = D.transform

@@ -262,2 +262,5 @@

export const zip: {
<Value2, Patch2>(
that: Differ<Value2, Patch2>
): <Value, Patch>(self: Differ<Value, Patch>) => Differ<readonly [Value, Value2], readonly [Patch, Patch2]>
<Value, Patch, Value2, Patch2>(

@@ -267,7 +270,2 @@ self: Differ<Value, Patch>,

): Differ<readonly [Value, Value2], readonly [Patch, Patch2]>
<Value2, Patch2>(
that: Differ<Value2, Patch2>
): <Value, Patch>(
self: Differ<Value, Patch>
) => Differ<readonly [Value, Value2], readonly [Patch, Patch2]>
} = D.zip

24

src/Differ/ChunkPatch.ts

@@ -59,11 +59,4 @@ /**

export const combine: {
<Value, Patch>(
self: ChunkPatch<Value, Patch>,
that: ChunkPatch<Value, Patch>
): ChunkPatch<Value, Patch>
<Value, Patch>(
that: ChunkPatch<Value, Patch>
): (
self: ChunkPatch<Value, Patch>
) => ChunkPatch<Value, Patch>
<Value, Patch>(that: ChunkPatch<Value, Patch>): (self: ChunkPatch<Value, Patch>) => ChunkPatch<Value, Patch>
<Value, Patch>(self: ChunkPatch<Value, Patch>, that: ChunkPatch<Value, Patch>): ChunkPatch<Value, Patch>
} = CP.combine

@@ -80,13 +73,4 @@

export const patch: {
<Value, Patch>(
self: ChunkPatch<Value, Patch>,
oldValue: Chunk<Value>,
differ: Differ<Value, Patch>
): Chunk<Value>
<Value, Patch>(
oldValue: Chunk<Value>,
differ: Differ<Value, Patch>
): (
self: ChunkPatch<Value, Patch>
) => Chunk<Value>
<Value, Patch>(oldValue: Chunk<Value>, differ: Differ<Value, Patch>): (self: ChunkPatch<Value, Patch>) => Chunk<Value>
<Value, Patch>(self: ChunkPatch<Value, Patch>, oldValue: Chunk<Value>, differ: Differ<Value, Patch>): Chunk<Value>
} = CP.patch

10

src/Differ/ContextPatch.ts

@@ -56,2 +56,5 @@ /**

export const combine: {
<Output, Output2>(
that: ContextPatch<Output, Output2>
): <Input>(self: ContextPatch<Input, Output>) => ContextPatch<Input, Output2>
<Input, Output, Output2>(

@@ -61,7 +64,2 @@ self: ContextPatch<Input, Output>,

): ContextPatch<Input, Output2>
<Output, Output2>(
that: ContextPatch<Output, Output2>
): <Input>(
self: ContextPatch<Input, Output>
) => ContextPatch<Input, Output2>
} = CP.combine

@@ -77,4 +75,4 @@

export const patch: {
<Input>(context: Context<Input>): <Output>(self: ContextPatch<Input, Output>) => Context<Output>
<Input, Output>(self: ContextPatch<Input, Output>, context: Context<Input>): Context<Output>
<Input>(context: Context<Input>): <Output>(self: ContextPatch<Input, Output>) => Context<Output>
} = CP.patch

16

src/Differ/HashMapPatch.ts

@@ -61,10 +61,8 @@ /**

<Key, Value, Patch>(
that: HashMapPatch<Key, Value, Patch>
): (self: HashMapPatch<Key, Value, Patch>) => HashMapPatch<Key, Value, Patch>
<Key, Value, Patch>(
self: HashMapPatch<Key, Value, Patch>,
that: HashMapPatch<Key, Value, Patch>
): HashMapPatch<Key, Value, Patch>
<Key, Value, Patch>(
that: HashMapPatch<Key, Value, Patch>
): (
self: HashMapPatch<Key, Value, Patch>
) => HashMapPatch<Key, Value, Patch>
} = HMP.combine

@@ -82,12 +80,10 @@

<Key, Value, Patch>(
self: HashMapPatch<Key, Value, Patch>,
oldValue: HashMap<Key, Value>,
differ: Differ<Value, Patch>
): HashMap<Key, Value>
): (self: HashMapPatch<Key, Value, Patch>) => HashMap<Key, Value>
<Key, Value, Patch>(
self: HashMapPatch<Key, Value, Patch>,
oldValue: HashMap<Key, Value>,
differ: Differ<Value, Patch>
): (
self: HashMapPatch<Key, Value, Patch>
) => HashMap<Key, Value>
): HashMap<Key, Value>
} = HMP.patch

4

src/Differ/HashSetPatch.ts

@@ -55,4 +55,4 @@ /**

export const combine: {
<Value>(that: HashSetPatch<Value>): (self: HashSetPatch<Value>) => HashSetPatch<Value>
<Value>(self: HashSetPatch<Value>, that: HashSetPatch<Value>): HashSetPatch<Value>
<Value>(that: HashSetPatch<Value>): (self: HashSetPatch<Value>) => HashSetPatch<Value>
} = HSP.combine

@@ -69,4 +69,4 @@

export const patch: {
<Value>(oldValue: HashSet<Value>): (self: HashSetPatch<Value>) => HashSet<Value>
<Value>(self: HashSetPatch<Value>, oldValue: HashSet<Value>): HashSet<Value>
<Value>(oldValue: HashSet<Value>): (self: HashSetPatch<Value>) => HashSet<Value>
} = HSP.patch

16

src/Differ/OrPatch.ts

@@ -68,10 +68,8 @@ /**

<Value, Value2, Patch, Patch2>(
that: OrPatch<Value, Value2, Patch, Patch2>
): (self: OrPatch<Value, Value2, Patch, Patch2>) => OrPatch<Value, Value2, Patch, Patch2>
<Value, Value2, Patch, Patch2>(
self: OrPatch<Value, Value2, Patch, Patch2>,
that: OrPatch<Value, Value2, Patch, Patch2>
): OrPatch<Value, Value2, Patch, Patch2>
<Value, Value2, Patch, Patch2>(
that: OrPatch<Value, Value2, Patch, Patch2>
): (
self: OrPatch<Value, Value2, Patch, Patch2>
) => OrPatch<Value, Value2, Patch, Patch2>
} = OP.combine

@@ -88,14 +86,12 @@

<Value, Value2, Patch, Patch2>(
self: OrPatch<Value, Value2, Patch, Patch2>,
oldValue: Either<Value, Value2>,
left: Differ<Value, Patch>,
right: Differ<Value2, Patch2>
): Either<Value, Value2>
): (self: OrPatch<Value, Value2, Patch, Patch2>) => Either<Value, Value2>
<Value, Value2, Patch, Patch2>(
self: OrPatch<Value, Value2, Patch, Patch2>,
oldValue: Either<Value, Value2>,
left: Differ<Value, Patch>,
right: Differ<Value2, Patch2>
): (
self: OrPatch<Value, Value2, Patch, Patch2>
) => Either<Value, Value2>
): Either<Value, Value2>
} = OP.patch

46

src/Duration.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as Dual from "@fp-ts/core/Function"

@@ -97,7 +97,7 @@ const TypeId: unique symbol = Symbol.for("@effect/data/Duration")

export const times: {
(times: number): (self: Duration) => Duration
(self: Duration, times: number): Duration
(times: number): (self: Duration) => Duration
} = Dual.dual<
(self: Duration, times: number) => Duration,
(times: number) => (self: Duration) => Duration
(times: number) => (self: Duration) => Duration,
(self: Duration, times: number) => Duration
>(2, (self, times) => new DurationImpl(self.millis * times))

@@ -110,7 +110,7 @@

export const add: {
(that: Duration): (self: Duration) => Duration
(self: Duration, that: Duration): Duration
(that: Duration): (self: Duration) => Duration
} = Dual.dual<
(self: Duration, that: Duration) => Duration,
(that: Duration) => (self: Duration) => Duration
(that: Duration) => (self: Duration) => Duration,
(self: Duration, that: Duration) => Duration
>(2, (self, that) => new DurationImpl(self.millis + that.millis))

@@ -123,7 +123,7 @@

export const subtract: {
(that: Duration): (self: Duration) => Duration
(self: Duration, that: Duration): Duration
(that: Duration): (self: Duration) => Duration
} = Dual.dual<
(self: Duration, that: Duration) => Duration,
(that: Duration) => (self: Duration) => Duration
(that: Duration) => (self: Duration) => Duration,
(self: Duration, that: Duration) => Duration
>(2, (self, that) => new DurationImpl(self.millis - that.millis))

@@ -136,7 +136,7 @@

export const lessThan: {
(that: Duration): (self: Duration) => boolean
(self: Duration, that: Duration): boolean
(that: Duration): (self: Duration) => boolean
} = Dual.dual<
(self: Duration, that: Duration) => boolean,
(that: Duration) => (self: Duration) => boolean
(that: Duration) => (self: Duration) => boolean,
(self: Duration, that: Duration) => boolean
>(2, (self, that) => self.millis < that.millis)

@@ -152,4 +152,4 @@

} = Dual.dual<
(self: Duration, that: Duration) => boolean,
(that: Duration) => (self: Duration) => boolean
(that: Duration) => (self: Duration) => boolean,
(self: Duration, that: Duration) => boolean
>(2, (self, that) => self.millis <= that.millis)

@@ -162,7 +162,7 @@

export const greaterThan: {
(that: Duration): (self: Duration) => boolean
(self: Duration, that: Duration): boolean
(that: Duration): (self: Duration) => boolean
} = Dual.dual<
(self: Duration, that: Duration) => boolean,
(that: Duration) => (self: Duration) => boolean
(that: Duration) => (self: Duration) => boolean,
(self: Duration, that: Duration) => boolean
>(2, (self, that) => self.millis > that.millis)

@@ -178,4 +178,4 @@

} = Dual.dual<
(self: Duration, that: Duration) => boolean,
(that: Duration) => (self: Duration) => boolean
(that: Duration) => (self: Duration) => boolean,
(self: Duration, that: Duration) => boolean
>(2, (self, that) => self.millis >= that.millis)

@@ -188,7 +188,7 @@

export const equals: {
(that: Duration): (self: Duration) => boolean
(self: Duration, that: Duration): boolean
(that: Duration): (self: Duration) => boolean
} = Dual.dual<
(self: Duration, that: Duration) => boolean,
(that: Duration) => (self: Duration) => boolean
(that: Duration) => (self: Duration) => boolean,
(self: Duration, that: Duration) => boolean
>(2, (self, that) => self.millis === that.millis)

54

src/HashMap.ts

@@ -83,4 +83,4 @@ /**

export const get: {
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>
<K, V, K1>(self: HashMap<K, V>, key: K1): Option<V>
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => Option<V>
} = HM.get

@@ -95,4 +95,4 @@

export const getHash: {
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>
<K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): Option<V>
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => Option<V>
} = HM.getHash

@@ -108,4 +108,4 @@

export const unsafeGet: {
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => V
<K, V, K1>(self: HashMap<K, V>, key: K1): V
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => V
} = HM.unsafeGet

@@ -120,4 +120,4 @@

export const has: {
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean
<K, V, K1>(self: HashMap<K, V>, key: K1): boolean
<K1>(key: K1): <K, V>(self: HashMap<K, V>) => boolean
} = HM.has

@@ -133,4 +133,4 @@

export const hasHash: {
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean
<K, V, K1>(self: HashMap<K, V>, key: K1, hash: number): boolean
<K1>(key: K1, hash: number): <K, V>(self: HashMap<K, V>) => boolean
} = HM.hasHash

@@ -146,4 +146,4 @@

export const set: {
<K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, key: K, value: V): HashMap<K, V>
<K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>
} = HM.set

@@ -206,4 +206,4 @@

export const mutate: {
<K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, f: (self: HashMap<K, V>) => void): HashMap<K, V>
<K, V>(f: (self: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>
} = HM.mutate

@@ -223,4 +223,4 @@

export const modifyAt: {
<K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, key: K, f: UpdateFn<V>): HashMap<K, V>
<K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>
} = HM.modifyAt

@@ -242,4 +242,4 @@

export const modifyHash: {
<K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V>
<K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>
} = HM.modifyHash

@@ -254,4 +254,4 @@

export const modify: {
<K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V>
<K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>
} = HM.modify

@@ -266,4 +266,4 @@

export const union: {
<K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>
<K0, V0, K1, V1>(self: HashMap<K0, V0>, that: HashMap<K1, V1>): HashMap<K0 | K1, V0 | V1>
<K1, V1>(that: HashMap<K1, V1>): <K0, V0>(self: HashMap<K0, V0>) => HashMap<K1 | K0, V1 | V0>
} = HM.union

@@ -279,4 +279,4 @@

export const remove: {
<K>(key: K): <V>(self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, key: K): HashMap<K, V>
<K>(key: K): <V>(self: HashMap<K, V>) => HashMap<K, V>
} = HM.remove

@@ -291,4 +291,4 @@

export const removeMany: {
<K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>
<K, V>(self: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V>
<K>(keys: Iterable<K>): <V>(self: HashMap<K, V>) => HashMap<K, V>
} = HM.removeMany

@@ -303,4 +303,4 @@

export const map: {
<V, A>(f: (value: V) => A): <K>(self: HashMap<K, V>) => HashMap<K, A>
<K, V, A>(self: HashMap<K, V>, f: (value: V) => A): HashMap<K, A>
<V, A>(f: (value: V) => A): <K>(self: HashMap<K, V>) => HashMap<K, A>
} = HM.map

@@ -315,4 +315,4 @@

export const mapWithIndex: {
<A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>
<K, V, A>(self: HashMap<K, V>, f: (value: V, key: K) => A): HashMap<K, A>
<A, V, K>(f: (value: V, key: K) => A): (self: HashMap<K, V>) => HashMap<K, A>
} = HM.mapWithIndex

@@ -329,4 +329,4 @@

export const flatMap: {
<K, A, B>(f: (value: A) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>
<K, A, B>(self: HashMap<K, A>, f: (value: A) => HashMap<K, B>): HashMap<K, B>
<K, A, B>(f: (value: A) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>
} = HM.flatMap

@@ -343,4 +343,4 @@

export const flatMapWithIndex: {
<A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>
<K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => HashMap<K, B>): HashMap<K, B>
<A, K, B>(f: (value: A, key: K) => HashMap<K, B>): (self: HashMap<K, A>) => HashMap<K, B>
} = HM.flatMapWithIndex

@@ -355,4 +355,4 @@

export const forEach: {
<V>(f: (value: V) => void): <K>(self: HashMap<K, V>) => void
<K, V>(self: HashMap<K, V>, f: (value: V) => void): void
<V>(f: (value: V) => void): <K>(self: HashMap<K, V>) => void
} = HM.forEach

@@ -367,4 +367,4 @@

export const forEachWithIndex: {
<V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void
<V, K>(self: HashMap<K, V>, f: (value: V, key: K) => void): void
<V, K>(f: (value: V, key: K) => void): (self: HashMap<K, V>) => void
} = HM.forEachWithIndex

@@ -379,4 +379,4 @@

export const reduce: {
<V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(self: HashMap<K, V>) => Z
<K, V, Z>(self: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z
<V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(self: HashMap<K, V>) => Z
} = HM.reduce

@@ -391,4 +391,4 @@

export const reduceWithIndex: {
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z
<Z, V, K>(self: HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: HashMap<K, V>) => Z
} = HM.reduceWithIndex

@@ -403,6 +403,6 @@

export const filter: {
<A, B extends A>(f: Refinement<A, B>): <K>(self: HashMap<K, A>) => HashMap<K, B>
<A>(f: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>
<K, A, B extends A>(self: HashMap<K, A>, f: Refinement<A, B>): HashMap<K, B>
<K, A>(self: HashMap<K, A>, f: Predicate<A>): HashMap<K, A>
<A, B extends A>(f: Refinement<A, B>): <K>(self: HashMap<K, A>) => HashMap<K, B>
<A>(f: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>
} = HM.filter

@@ -417,6 +417,6 @@

export const filterWithIndex: {
<K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
<K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
<K, A, B extends A>(self: HashMap<K, A>, f: (a: A, k: K) => a is B): HashMap<K, B>
<K, A>(self: HashMap<K, A>, f: (a: A, k: K) => boolean): HashMap<K, A>
<K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HashMap<K, A>) => HashMap<K, B>
<K, A>(f: (a: A, k: K) => boolean): (self: HashMap<K, A>) => HashMap<K, A>
} = HM.filterWithIndex

@@ -440,4 +440,4 @@

export const filterMap: {
<A, B>(f: (value: A) => Option<B>): <K>(self: HashMap<K, A>) => HashMap<K, B>
<K, A, B>(self: HashMap<K, A>, f: (value: A) => Option<B>): HashMap<K, B>
<A, B>(f: (value: A) => Option<B>): <K>(self: HashMap<K, A>) => HashMap<K, B>
} = HM.filterMap

@@ -453,4 +453,4 @@

export const filterMapWithIndex: {
<A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>
<K, A, B>(self: HashMap<K, A>, f: (value: A, key: K) => Option<B>): HashMap<K, B>
<A, K, B>(f: (value: A, key: K) => Option<B>): (self: HashMap<K, A>) => HashMap<K, B>
} = HM.filterMapWithIndex

38

src/HashSet.ts

@@ -65,4 +65,4 @@ /**

export const has: {
<A>(value: A): (self: HashSet<A>) => boolean
<A>(self: HashSet<A>, value: A): boolean
<A>(value: A): (self: HashSet<A>) => boolean
} = HS.has

@@ -77,4 +77,4 @@

export const some: {
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean
<A>(self: HashSet<A>, f: Predicate<A>): boolean
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean
} = HS.some

@@ -90,4 +90,4 @@

export const every: {
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean
<A>(self: HashSet<A>, f: Predicate<A>): boolean
<A>(f: Predicate<A>): (self: HashSet<A>) => boolean
} = HS.every

@@ -105,4 +105,4 @@

export const isSubset: {
<A>(that: HashSet<A>): (self: HashSet<A>) => boolean
<A>(self: HashSet<A>, that: HashSet<A>): boolean
<A>(that: HashSet<A>): (self: HashSet<A>) => boolean
} = HS.isSubset

@@ -149,4 +149,4 @@

export const mutate: {
<A>(f: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, f: (set: HashSet<A>) => void): HashSet<A>
<A>(f: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>
} = HS.mutate

@@ -161,4 +161,4 @@

export const add: {
<A>(value: A): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, value: A): HashSet<A>
<A>(value: A): (self: HashSet<A>) => HashSet<A>
} = HS.add

@@ -173,4 +173,4 @@

export const remove: {
<A>(value: A): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, value: A): HashSet<A>
<A>(value: A): (self: HashSet<A>) => HashSet<A>
} = HS.remove

@@ -189,4 +189,4 @@

export const difference: {
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
} = HS.difference

@@ -205,4 +205,4 @@

export const intersection: {
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
} = HS.intersection

@@ -221,4 +221,4 @@

export const union: {
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>
<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>
} = HS.union

@@ -235,4 +235,4 @@

export const toggle: {
<A>(value: A): (self: HashSet<A>) => HashSet<A>
<A>(self: HashSet<A>, value: A): HashSet<A>
<A>(value: A): (self: HashSet<A>) => HashSet<A>
} = HS.toggle

@@ -247,4 +247,4 @@

export const map: {
<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>
<A, B>(self: HashSet<A>, f: (a: A) => B): HashSet<B>
<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>
} = HS.map

@@ -259,4 +259,4 @@

export const flatMap: {
<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>
<A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>): HashSet<B>
<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>
} = HS.flatMap

@@ -271,4 +271,4 @@

export const forEach: {
<A>(f: (value: A) => void): (self: HashSet<A>) => void
<A>(self: HashSet<A>, f: (value: A) => void): void
<A>(f: (value: A) => void): (self: HashSet<A>) => void
} = HS.forEach

@@ -283,4 +283,4 @@

export const reduce: {
<A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet<A>) => Z
<A, Z>(self: HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z): Z
<A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: HashSet<A>) => Z
} = HS.reduce

@@ -295,6 +295,6 @@

export const filter: {
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
<A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>
<A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): HashSet<B>
<A>(self: HashSet<A>, f: Predicate<A>): HashSet<A>
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => HashSet<B>
<A>(f: Predicate<A>): (self: HashSet<A>) => HashSet<A>
} = HS.filter

@@ -313,6 +313,6 @@

export const partition: {
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<B>]
<A>(f: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>]
<A, B extends A>(self: HashSet<A>, f: Refinement<A, B>): readonly [HashSet<A>, HashSet<B>]
<A>(self: HashSet<A>, f: Predicate<A>): readonly [HashSet<A>, HashSet<A>]
<A, B extends A>(f: Refinement<A, B>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<B>]
<A>(f: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>]
} = HS.partition

5

src/index.ts

@@ -15,3 +15,2 @@ /**

import * as orPatch from "@effect/data/Differ/OrPatch"
import * as dual from "@effect/data/Dual"
import * as duration from "@effect/data/Duration"

@@ -67,6 +66,2 @@ import * as equal from "@effect/data/Equal"

*/
dual,
/**
* @since 1.0.0
*/
duration,

@@ -73,0 +68,0 @@ /**

30

src/internal/Context.ts
import type * as C from "@effect/data/Context"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as Dual from "@fp-ts/core/Function"
import type * as O from "@fp-ts/core/Option"

@@ -79,7 +79,2 @@ import * as option from "@fp-ts/core/Option"

export const add = Dual.dual<
<Services, T extends C.Tag<any>>(
self: C.Context<Services>,
tag: C.Tag<T>,
service: C.Tag.Service<T>
) => C.Context<Services | C.Tag.Service<T>>,
<T extends C.Tag<any>>(

@@ -90,2 +85,7 @@ tag: T,

self: C.Context<Services>
) => C.Context<Services | C.Tag.Service<T>>,
<Services, T extends C.Tag<any>>(
self: C.Context<Services>,
tag: C.Tag<T>,
service: C.Tag.Service<T>
) => C.Context<Services | C.Tag.Service<T>>

@@ -101,9 +101,9 @@ >(3, (self, tag, service) => {

<Services, T extends C.Tags<Services>>(
self: C.Context<Services>,
tag: T
) => (
self: C.Context<Services>
) => T extends C.Tag<infer S> ? S : never,
<Services, T extends C.Tags<Services>>(
self: C.Context<Services>,
tag: T
) => (
self: C.Context<Services>
) => T extends C.Tag<infer S> ? S : never

@@ -119,4 +119,4 @@ >(2, (self, tag) => {

export const unsafeGet = Dual.dual<
<Services, S>(self: C.Context<Services>, tag: C.Tag<S>) => S,
<S>(tag: C.Tag<S>) => <Services>(self: C.Context<Services>) => S
<S>(tag: C.Tag<S>) => <Services>(self: C.Context<Services>) => S,
<Services, S>(self: C.Context<Services>, tag: C.Tag<S>) => S
>(2, (self, tag) => {

@@ -131,4 +131,4 @@ if (!self.unsafeMap.has(tag)) {

export const getOption = Dual.dual<
<Services, S>(self: C.Context<Services>, tag: C.Tag<S>) => O.Option<S>,
<S>(tag: C.Tag<S>) => <Services>(self: C.Context<Services>) => O.Option<S>
<S>(tag: C.Tag<S>) => <Services>(self: C.Context<Services>) => O.Option<S>,
<Services, S>(self: C.Context<Services>, tag: C.Tag<S>) => O.Option<S>
>(2, (self, tag) => {

@@ -143,4 +143,4 @@ if (!self.unsafeMap.has(tag)) {

export const merge = Dual.dual<
<Services, R1>(self: C.Context<Services>, that: C.Context<R1>) => C.Context<Services | R1>,
<R1>(that: C.Context<R1>) => <Services>(self: C.Context<Services>) => C.Context<Services | R1>
<R1>(that: C.Context<R1>) => <Services>(self: C.Context<Services>) => C.Context<Services | R1>,
<Services, R1>(self: C.Context<Services>, that: C.Context<R1>) => C.Context<Services | R1>
>(2, (self, that) => {

@@ -147,0 +147,0 @@ const map = new Map(self.unsafeMap)

24

src/internal/Differ.ts

@@ -9,3 +9,2 @@ import type { Chunk } from "@effect/data/Chunk"

import * as OrPatch from "@effect/data/Differ/OrPatch"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"

@@ -15,2 +14,3 @@ import type { HashMap } from "@effect/data/HashMap"

import type { Either } from "@fp-ts/core/Either"
import * as Dual from "@fp-ts/core/Function"
import { constant, identity } from "@fp-ts/core/Function"

@@ -93,8 +93,8 @@

export const orElseResult = Dual.dual<
<Value2, Patch2>(that: D.Differ<Value2, Patch2>) => <Value, Patch>(
self: D.Differ<Value, Patch>
) => D.Differ<Either<Value, Value2>, OrPatch.OrPatch<Value, Value2, Patch, Patch2>>,
<Value, Patch, Value2, Patch2>(
self: D.Differ<Value, Patch>,
that: D.Differ<Value2, Patch2>
) => D.Differ<Either<Value, Value2>, OrPatch.OrPatch<Value, Value2, Patch, Patch2>>,
<Value2, Patch2>(that: D.Differ<Value2, Patch2>) => <Value, Patch>(
self: D.Differ<Value, Patch>
) => D.Differ<Either<Value, Value2>, OrPatch.OrPatch<Value, Value2, Patch, Patch2>>

@@ -111,2 +111,6 @@ >(2, (self, that) =>

export const transform = Dual.dual<
<Value, Value2>(
f: (value: Value) => Value2,
g: (value: Value2) => Value
) => <Patch>(self: D.Differ<Value, Patch>) => D.Differ<Value2, Patch>,
<Value, Patch, Value2>(

@@ -116,7 +120,3 @@ self: D.Differ<Value, Patch>,

g: (value: Value2) => Value
) => D.Differ<Value2, Patch>,
<Value, Value2>(
f: (value: Value) => Value2,
g: (value: Value2) => Value
) => <Patch>(self: D.Differ<Value, Patch>) => D.Differ<Value2, Patch>
) => D.Differ<Value2, Patch>
>(3, (self, f, g) =>

@@ -157,8 +157,8 @@ make({

export const zip = Dual.dual<
<Value2, Patch2>(that: D.Differ<Value2, Patch2>) => <Value, Patch>(
self: D.Differ<Value, Patch>
) => D.Differ<readonly [Value, Value2], readonly [Patch, Patch2]>,
<Value, Patch, Value2, Patch2>(
self: D.Differ<Value, Patch>,
that: D.Differ<Value2, Patch2>
) => D.Differ<readonly [Value, Value2], readonly [Patch, Patch2]>,
<Value2, Patch2>(that: D.Differ<Value2, Patch2>) => <Value, Patch>(
self: D.Differ<Value, Patch>
) => D.Differ<readonly [Value, Value2], readonly [Patch, Patch2]>

@@ -165,0 +165,0 @@ >(2, (self, that) =>

14

src/internal/Differ/ChunkPatch.ts
import * as Chunk from "@effect/data/Chunk"
import type { Differ } from "@effect/data/Differ"
import type * as CP from "@effect/data/Differ/ChunkPatch"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as Dual from "@fp-ts/core/Function"
import { pipe } from "@fp-ts/core/Function"

@@ -150,9 +150,9 @@

<Value, Patch>(
self: CP.ChunkPatch<Value, Patch>,
that: CP.ChunkPatch<Value, Patch>
) => (
self: CP.ChunkPatch<Value, Patch>
) => CP.ChunkPatch<Value, Patch>,
<Value, Patch>(
self: CP.ChunkPatch<Value, Patch>,
that: CP.ChunkPatch<Value, Patch>
) => (
self: CP.ChunkPatch<Value, Patch>
) => CP.ChunkPatch<Value, Patch>

@@ -164,10 +164,10 @@ >(2, (self, that) => new AndThen(self, that))

<Value, Patch>(
self: CP.ChunkPatch<Value, Patch>,
oldValue: Chunk.Chunk<Value>,
differ: Differ<Value, Patch>
) => Chunk.Chunk<Value>,
) => (self: CP.ChunkPatch<Value, Patch>) => Chunk.Chunk<Value>,
<Value, Patch>(
self: CP.ChunkPatch<Value, Patch>,
oldValue: Chunk.Chunk<Value>,
differ: Differ<Value, Patch>
) => (self: CP.ChunkPatch<Value, Patch>) => Chunk.Chunk<Value>
) => Chunk.Chunk<Value>
>(3, <Value, Patch>(

@@ -174,0 +174,0 @@ self: CP.ChunkPatch<Value, Patch>,

18

src/internal/Differ/ContextPatch.ts
import * as Chunk from "@effect/data/Chunk"
import type { Context, Tag } from "@effect/data/Context"
import type * as CP from "@effect/data/Differ/ContextPatch"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import { ContextImpl } from "@effect/data/internal/Context"
import * as Dual from "@fp-ts/core/Function"

@@ -158,6 +158,2 @@ /** @internal */

export const combine = Dual.dual<
<Input, Output, Output2>(
self: CP.ContextPatch<Input, Output>,
that: CP.ContextPatch<Output, Output2>
) => CP.ContextPatch<Input, Output2>,
<Output, Output2>(

@@ -167,2 +163,6 @@ that: CP.ContextPatch<Output, Output2>

self: CP.ContextPatch<Input, Output>
) => CP.ContextPatch<Input, Output2>,
<Input, Output, Output2>(
self: CP.ContextPatch<Input, Output>,
that: CP.ContextPatch<Output, Output2>
) => CP.ContextPatch<Input, Output2>

@@ -173,6 +173,2 @@ >(2, (self, that) => new AndThen(self, that))

export const patch = Dual.dual<
<Input, Output>(
self: CP.ContextPatch<Input, Output>,
context: Context<Input>
) => Context<Output>,
<Input>(

@@ -182,2 +178,6 @@ context: Context<Input>

self: CP.ContextPatch<Input, Output>
) => Context<Output>,
<Input, Output>(
self: CP.ContextPatch<Input, Output>,
context: Context<Input>
) => Context<Output>

@@ -184,0 +184,0 @@ >(2, <Input, Output>(self: CP.ContextPatch<Input, Output>, context: Context<Input>) => {

14

src/internal/Differ/HashMapPatch.ts
import * as Chunk from "@effect/data/Chunk"
import type * as Differ from "@effect/data/Differ"
import type * as HMP from "@effect/data/Differ/HashMapPatch"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as HashMap from "@effect/data/HashMap"
import * as Dual from "@fp-ts/core/Function"

@@ -163,9 +163,9 @@ /** @internal */

<Key, Value, Patch>(
self: HMP.HashMapPatch<Key, Value, Patch>,
that: HMP.HashMapPatch<Key, Value, Patch>
) => (
self: HMP.HashMapPatch<Key, Value, Patch>
) => HMP.HashMapPatch<Key, Value, Patch>,
<Key, Value, Patch>(
self: HMP.HashMapPatch<Key, Value, Patch>,
that: HMP.HashMapPatch<Key, Value, Patch>
) => (
self: HMP.HashMapPatch<Key, Value, Patch>
) => HMP.HashMapPatch<Key, Value, Patch>

@@ -177,11 +177,11 @@ >(2, (self, that) => new AndThen(self, that))

<Key, Value, Patch>(
self: HMP.HashMapPatch<Key, Value, Patch>,
oldValue: HashMap.HashMap<Key, Value>,
differ: Differ.Differ<Value, Patch>
) => (
self: HMP.HashMapPatch<Key, Value, Patch>
) => HashMap.HashMap<Key, Value>,
<Key, Value, Patch>(
self: HMP.HashMapPatch<Key, Value, Patch>,
oldValue: HashMap.HashMap<Key, Value>,
differ: Differ.Differ<Value, Patch>
) => (
self: HMP.HashMapPatch<Key, Value, Patch>
) => HashMap.HashMap<Key, Value>

@@ -188,0 +188,0 @@ >(3, <Key, Value, Patch>(

14

src/internal/Differ/HashSetPatch.ts
import * as Chunk from "@effect/data/Chunk"
import type * as HSP from "@effect/data/Differ/HashSetPatch"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as HashSet from "@effect/data/HashSet"
import * as Dual from "@fp-ts/core/Function"

@@ -116,9 +116,9 @@ /** @internal */

<Value>(
self: HSP.HashSetPatch<Value>,
that: HSP.HashSetPatch<Value>
) => (
self: HSP.HashSetPatch<Value>
) => HSP.HashSetPatch<Value>,
<Value>(
self: HSP.HashSetPatch<Value>,
that: HSP.HashSetPatch<Value>
) => (
self: HSP.HashSetPatch<Value>
) => HSP.HashSetPatch<Value>

@@ -130,9 +130,9 @@ >(2, (self, that) => new AndThen(self, that))

<Value>(
self: HSP.HashSetPatch<Value>,
oldValue: HashSet.HashSet<Value>
) => (
self: HSP.HashSetPatch<Value>
) => HashSet.HashSet<Value>,
<Value>(
self: HSP.HashSetPatch<Value>,
oldValue: HashSet.HashSet<Value>
) => (
self: HSP.HashSetPatch<Value>
) => HashSet.HashSet<Value>

@@ -139,0 +139,0 @@ >(2, <Value>(

14

src/internal/Differ/OrPatch.ts
import * as Chunk from "@effect/data/Chunk"
import type { Differ } from "@effect/data/Differ"
import type * as OP from "@effect/data/Differ/OrPatch"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"

@@ -9,2 +8,3 @@ import * as Hash from "@effect/data/Hash"

import * as E from "@fp-ts/core/Either"
import * as Dual from "@fp-ts/core/Function"

@@ -204,9 +204,9 @@ /** @internal */

<Value, Value2, Patch, Patch2>(
self: OP.OrPatch<Value, Value2, Patch, Patch2>,
that: OP.OrPatch<Value, Value2, Patch, Patch2>
) => (
self: OP.OrPatch<Value, Value2, Patch, Patch2>
) => OP.OrPatch<Value, Value2, Patch, Patch2>,
<Value, Value2, Patch, Patch2>(
self: OP.OrPatch<Value, Value2, Patch, Patch2>,
that: OP.OrPatch<Value, Value2, Patch, Patch2>
) => (
self: OP.OrPatch<Value, Value2, Patch, Patch2>
) => OP.OrPatch<Value, Value2, Patch, Patch2>

@@ -218,12 +218,12 @@ >(2, (self, that) => new AndThen(self, that))

<Value, Value2, Patch, Patch2>(
self: OP.OrPatch<Value, Value2, Patch, Patch2>,
oldValue: Either<Value, Value2>,
left: Differ<Value, Patch>,
right: Differ<Value2, Patch2>
) => Either<Value, Value2>,
) => (self: OP.OrPatch<Value, Value2, Patch, Patch2>) => Either<Value, Value2>,
<Value, Value2, Patch, Patch2>(
self: OP.OrPatch<Value, Value2, Patch, Patch2>,
oldValue: Either<Value, Value2>,
left: Differ<Value, Patch>,
right: Differ<Value2, Patch2>
) => (self: OP.OrPatch<Value, Value2, Patch, Patch2>) => Either<Value, Value2>
) => Either<Value, Value2>
>(4, <Value, Value2, Patch, Patch2>(

@@ -230,0 +230,0 @@ self: OP.OrPatch<Value, Value2, Patch, Patch2>,

118

src/internal/HashMap.ts

@@ -1,2 +0,1 @@

import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"

@@ -8,2 +7,3 @@ import * as Hash from "@effect/data/Hash"

import * as Node from "@effect/data/internal/HashMap/node"
import * as Dual from "@fp-ts/core/Function"
import { identity, pipe } from "@fp-ts/core/Function"

@@ -197,4 +197,4 @@ import * as Option from "@fp-ts/core/Option"

export const get = Dual.dual<
<K, V, K1>(self: HM.HashMap<K, V>, key: K1) => Option.Option<V>,
<K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => Option.Option<V>
<K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => Option.Option<V>,
<K, V, K1>(self: HM.HashMap<K, V>, key: K1) => Option.Option<V>
>(2, (self, key) => getHash(self, key, Hash.hash(key)))

@@ -204,4 +204,4 @@

export const getHash = Dual.dual<
<K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => Option.Option<V>,
<K1>(key: K1, hash: number) => <K, V>(self: HM.HashMap<K, V>) => Option.Option<V>
<K1>(key: K1, hash: number) => <K, V>(self: HM.HashMap<K, V>) => Option.Option<V>,
<K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => Option.Option<V>
>(3, <K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => {

@@ -254,4 +254,4 @@ let node = (self as HashMapImpl<K, V>)._root

export const unsafeGet = Dual.dual<
<K, V, K1>(self: HM.HashMap<K, V>, key: K1) => V,
<K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => V
<K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => V,
<K, V, K1>(self: HM.HashMap<K, V>, key: K1) => V
>(2, (self, key) => {

@@ -267,4 +267,4 @@ const element = getHash(self, key, Hash.hash(key))

export const has = Dual.dual<
<K, V, K1>(self: HM.HashMap<K, V>, key: K1) => boolean,
<K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => boolean
<K1>(key: K1) => <K, V>(self: HM.HashMap<K, V>) => boolean,
<K, V, K1>(self: HM.HashMap<K, V>, key: K1) => boolean
>(2, (self, key) => Option.isSome(getHash(self, key, Hash.hash(key))))

@@ -274,4 +274,4 @@

export const hasHash = Dual.dual<
<K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => boolean,
<K1>(key: K1, hash: number) => <K, V>(self: HM.HashMap<K, V>) => boolean
<K1>(key: K1, hash: number) => <K, V>(self: HM.HashMap<K, V>) => boolean,
<K, V, K1>(self: HM.HashMap<K, V>, key: K1, hash: number) => boolean
>(3, (self, key, hash) => Option.isSome(getHash(self, key, hash)))

@@ -281,4 +281,4 @@

export const set = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, key: K, value: V) => HM.HashMap<K, V>,
<K, V>(key: K, value: V) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K, V>(key: K, value: V) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, key: K, value: V) => HM.HashMap<K, V>
>(3, (self, key, value) => modifyAt(self, key, () => Option.some(value)))

@@ -288,4 +288,4 @@

export const setTree = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, newRoot: Node.Node<K, V>, newSize: number) => HM.HashMap<K, V>,
<K, V>(newRoot: Node.Node<K, V>, newSize: number) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K, V>(newRoot: Node.Node<K, V>, newSize: number) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, newRoot: Node.Node<K, V>, newSize: number) => HM.HashMap<K, V>
>(3, <K, V>(self: HM.HashMap<K, V>, newRoot: Node.Node<K, V>, newSize: number) => {

@@ -335,4 +335,4 @@ if ((self as HashMapImpl<K, V>)._editable) {

export const mutate = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, f: (self: HM.HashMap<K, V>) => void) => HM.HashMap<K, V>,
<K, V>(f: (self: HM.HashMap<K, V>) => void) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K, V>(f: (self: HM.HashMap<K, V>) => void) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, f: (self: HM.HashMap<K, V>) => void) => HM.HashMap<K, V>
>(2, (self, f) => {

@@ -346,4 +346,4 @@ const transient = beginMutation(self)

export const modifyAt = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, key: K, f: Node.UpdateFn<V>) => HM.HashMap<K, V>,
<K, V>(key: K, f: Node.UpdateFn<V>) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K, V>(key: K, f: Node.UpdateFn<V>) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, key: K, f: Node.UpdateFn<V>) => HM.HashMap<K, V>
>(3, (self, key, f) => modifyHash(self, key, Hash.hash(key), f))

@@ -353,4 +353,4 @@

export const modifyHash = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, key: K, hash: number, f: Node.UpdateFn<V>) => HM.HashMap<K, V>,
<K, V>(key: K, hash: number, f: Node.UpdateFn<V>) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K, V>(key: K, hash: number, f: Node.UpdateFn<V>) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, key: K, hash: number, f: Node.UpdateFn<V>) => HM.HashMap<K, V>
>(4, <K, V>(self: HM.HashMap<K, V>, key: K, hash: number, f: Node.UpdateFn<V>) => {

@@ -373,4 +373,4 @@ const size = { value: (self as HashMapImpl<K, V>)._size }

export const modify = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, key: K, f: (v: V) => V) => HM.HashMap<K, V>,
<K, V>(key: K, f: (v: V) => V) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K, V>(key: K, f: (v: V) => V) => (self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, key: K, f: (v: V) => V) => HM.HashMap<K, V>
>(3, (self, key, f) => modifyAt(self, key, Option.map(f)))

@@ -380,9 +380,9 @@

export const union = Dual.dual<
<K1, V1>(
that: HM.HashMap<K1, V1>
) => <K0, V0>(self: HM.HashMap<K0, V0>) => HM.HashMap<K0 | K1, V0 | V1>,
<K0, V0, K1, V1>(
self: HM.HashMap<K0, V0>,
that: HM.HashMap<K1, V1>
) => HM.HashMap<K0 | K1, V0 | V1>,
<K1, V1>(
that: HM.HashMap<K1, V1>
) => <K0, V0>(self: HM.HashMap<K0, V0>) => HM.HashMap<K0 | K1, V0 | V1>
) => HM.HashMap<K0 | K1, V0 | V1>
>(2, <K0, V0, K1, V1>(self: HM.HashMap<K0, V0>, that: HM.HashMap<K1, V1>) => {

@@ -396,4 +396,4 @@ const result: HM.HashMap<K0 | K1, V0 | V1> = beginMutation(self)

export const remove = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, key: K) => HM.HashMap<K, V>,
<K>(key: K) => <V>(self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K>(key: K) => <V>(self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, key: K) => HM.HashMap<K, V>
>(2, (self, key) => modifyAt(self, key, Option.none))

@@ -403,4 +403,4 @@

export const removeMany = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, keys: Iterable<K>) => HM.HashMap<K, V>,
<K>(keys: Iterable<K>) => <V>(self: HM.HashMap<K, V>) => HM.HashMap<K, V>
<K>(keys: Iterable<K>) => <V>(self: HM.HashMap<K, V>) => HM.HashMap<K, V>,
<K, V>(self: HM.HashMap<K, V>, keys: Iterable<K>) => HM.HashMap<K, V>
>(2, (self, keys) =>

@@ -415,4 +415,4 @@ mutate(self, (map) => {

export const map = Dual.dual<
<K, V, A>(self: HM.HashMap<K, V>, f: (value: V) => A) => HM.HashMap<K, A>,
<V, A>(f: (value: V) => A) => <K>(self: HM.HashMap<K, V>) => HM.HashMap<K, A>
<V, A>(f: (value: V) => A) => <K>(self: HM.HashMap<K, V>) => HM.HashMap<K, A>,
<K, V, A>(self: HM.HashMap<K, V>, f: (value: V) => A) => HM.HashMap<K, A>
>(2, (self, f) => mapWithIndex(self, (v) => f(v)))

@@ -427,4 +427,4 @@

export const mapWithIndex = Dual.dual<
<K, V, A>(self: HM.HashMap<K, V>, f: (value: V, key: K) => A) => HM.HashMap<K, A>,
<A, V, K>(f: (value: V, key: K) => A) => (self: HM.HashMap<K, V>) => HM.HashMap<K, A>
<A, V, K>(f: (value: V, key: K) => A) => (self: HM.HashMap<K, V>) => HM.HashMap<K, A>,
<K, V, A>(self: HM.HashMap<K, V>, f: (value: V, key: K) => A) => HM.HashMap<K, A>
>(2, (self, f) =>

@@ -439,4 +439,4 @@ reduceWithIndex(

export const flatMap = Dual.dual<
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A) => HM.HashMap<K, B>) => HM.HashMap<K, B>,
<K, A, B>(f: (value: A) => HM.HashMap<K, B>) => (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
<K, A, B>(f: (value: A) => HM.HashMap<K, B>) => (self: HM.HashMap<K, A>) => HM.HashMap<K, B>,
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A) => HM.HashMap<K, B>) => HM.HashMap<K, B>
>(2, (self, f) => flatMapWithIndex(self, (v) => f(v)))

@@ -446,6 +446,6 @@

export const flatMapWithIndex = Dual.dual<
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A, key: K) => HM.HashMap<K, B>) => HM.HashMap<K, B>,
<A, K, B>(
f: (value: A, key: K) => HM.HashMap<K, B>
) => (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
) => (self: HM.HashMap<K, A>) => HM.HashMap<K, B>,
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A, key: K) => HM.HashMap<K, B>) => HM.HashMap<K, B>
>(

@@ -463,4 +463,4 @@ 2,

export const forEach = Dual.dual<
<K, V>(self: HM.HashMap<K, V>, f: (value: V) => void) => void,
<V>(f: (value: V) => void) => <K>(self: HM.HashMap<K, V>) => void
<V>(f: (value: V) => void) => <K>(self: HM.HashMap<K, V>) => void,
<K, V>(self: HM.HashMap<K, V>, f: (value: V) => void) => void
>(2, (self, f) => forEachWithIndex(self, (value) => f(value)))

@@ -470,4 +470,4 @@

export const forEachWithIndex = Dual.dual<
<V, K>(self: HM.HashMap<K, V>, f: (value: V, key: K) => void) => void,
<V, K>(f: (value: V, key: K) => void) => (self: HM.HashMap<K, V>) => void
<V, K>(f: (value: V, key: K) => void) => (self: HM.HashMap<K, V>) => void,
<V, K>(self: HM.HashMap<K, V>, f: (value: V, key: K) => void) => void
>(2, (self, f) => reduceWithIndex(self, void 0 as void, (_, value, key) => f(value, key)))

@@ -477,4 +477,4 @@

export const reduce = Dual.dual<
<K, V, Z>(self: HM.HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z) => Z,
<V, Z>(z: Z, f: (z: Z, v: V) => Z) => <K>(self: HM.HashMap<K, V>) => Z
<V, Z>(z: Z, f: (z: Z, v: V) => Z) => <K>(self: HM.HashMap<K, V>) => Z,
<K, V, Z>(self: HM.HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z) => Z
>(3, (self, z, f) => reduceWithIndex(self, z, (acc, v) => f(acc, v)))

@@ -484,4 +484,4 @@

export const reduceWithIndex = Dual.dual<
<Z, V, K>(self: HM.HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => Z,
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => (self: HM.HashMap<K, V>) => Z
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => (self: HM.HashMap<K, V>) => Z,
<Z, V, K>(self: HM.HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => Z
>(3, <Z, V, K>(self: HM.HashMap<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => {

@@ -517,8 +517,8 @@ const root = (self as HashMapImpl<K, V>)._root

{
<A, B extends A>(f: Refinement<A, B>): <K>(self: HM.HashMap<K, A>) => HM.HashMap<K, B>
<A>(f: Predicate<A>): <K>(self: HM.HashMap<K, A>) => HM.HashMap<K, A>
},
{
<K, A, B extends A>(self: HM.HashMap<K, A>, f: Refinement<A, B>): HM.HashMap<K, B>
<K, A>(self: HM.HashMap<K, A>, f: Predicate<A>): HM.HashMap<K, A>
},
{
<A, B extends A>(f: Refinement<A, B>): <K>(self: HM.HashMap<K, A>) => HM.HashMap<K, B>
<A>(f: Predicate<A>): <K>(self: HM.HashMap<K, A>) => HM.HashMap<K, A>
}

@@ -530,8 +530,8 @@ >(2, <K, A>(self: HM.HashMap<K, A>, f: Predicate<A>) => filterWithIndex(self, f))

{
<K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
<K, A>(f: (a: A, k: K) => boolean): (self: HM.HashMap<K, A>) => HM.HashMap<K, A>
},
{
<K, A, B extends A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => a is B): HM.HashMap<K, B>
<K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean): HM.HashMap<K, A>
},
{
<K, A, B extends A>(f: (a: A, k: K) => a is B): (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
<K, A>(f: (a: A, k: K) => boolean): (self: HM.HashMap<K, A>) => HM.HashMap<K, A>
}

@@ -552,4 +552,4 @@ >(2, <K, A>(self: HM.HashMap<K, A>, f: (a: A, k: K) => boolean) =>

export const filterMap = Dual.dual<
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A) => Option.Option<B>) => HM.HashMap<K, B>,
<A, B>(f: (value: A) => Option.Option<B>) => <K>(self: HM.HashMap<K, A>) => HM.HashMap<K, B>
<A, B>(f: (value: A) => Option.Option<B>) => <K>(self: HM.HashMap<K, A>) => HM.HashMap<K, B>,
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A) => Option.Option<B>) => HM.HashMap<K, B>
>(2, (self, f) => filterMapWithIndex(self, f))

@@ -559,6 +559,6 @@

export const filterMapWithIndex = Dual.dual<
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>) => HM.HashMap<K, B>,
<A, K, B>(
f: (value: A, key: K) => Option.Option<B>
) => (self: HM.HashMap<K, A>) => HM.HashMap<K, B>
) => (self: HM.HashMap<K, A>) => HM.HashMap<K, B>,
<K, A, B>(self: HM.HashMap<K, A>, f: (value: A, key: K) => Option.Option<B>) => HM.HashMap<K, B>
>(2, (self, f) =>

@@ -565,0 +565,0 @@ mutate(empty(), (map) => {

82

src/internal/HashSet.ts

@@ -1,2 +0,1 @@

import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"

@@ -7,2 +6,3 @@ import * as Hash from "@effect/data/Hash"

import * as HM from "@effect/data/internal/HashMap"
import * as Dual from "@fp-ts/core/Function"
import type { Predicate, Refinement } from "@fp-ts/core/Predicate"

@@ -83,4 +83,4 @@

export const has = Dual.dual<
<A>(self: HS.HashSet<A>, value: A) => boolean,
<A>(value: A) => (self: HS.HashSet<A>) => boolean
<A>(value: A) => (self: HS.HashSet<A>) => boolean,
<A>(self: HS.HashSet<A>, value: A) => boolean
>(2, <A>(self: HS.HashSet<A>, value: A) => HM.has((self as HashSetImpl<A>)._keyMap, value))

@@ -90,4 +90,4 @@

export const some = Dual.dual<
<A>(self: HS.HashSet<A>, f: Predicate<A>) => boolean,
<A>(f: Predicate<A>) => (self: HS.HashSet<A>) => boolean
<A>(f: Predicate<A>) => (self: HS.HashSet<A>) => boolean,
<A>(self: HS.HashSet<A>, f: Predicate<A>) => boolean
>(2, (self, f) => {

@@ -106,4 +106,4 @@ let found = false

export const every = Dual.dual<
<A>(self: HS.HashSet<A>, f: Predicate<A>) => boolean,
<A>(f: Predicate<A>) => (self: HS.HashSet<A>) => boolean
<A>(f: Predicate<A>) => (self: HS.HashSet<A>) => boolean,
<A>(self: HS.HashSet<A>, f: Predicate<A>) => boolean
>(2, (self, f) => !some(self, (a) => !f(a)))

@@ -113,4 +113,4 @@

export const isSubset = Dual.dual<
<A>(self: HS.HashSet<A>, that: HS.HashSet<A>) => boolean,
<A>(that: HS.HashSet<A>) => (self: HS.HashSet<A>) => boolean
<A>(that: HS.HashSet<A>) => (self: HS.HashSet<A>) => boolean,
<A>(self: HS.HashSet<A>, that: HS.HashSet<A>) => boolean
>(2, (self, that) => every(self, (value) => has(that, value)))

@@ -136,4 +136,4 @@

export const mutate = Dual.dual<
<A>(self: HS.HashSet<A>, f: (set: HS.HashSet<A>) => void) => HS.HashSet<A>,
<A>(f: (set: HS.HashSet<A>) => void) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(f: (set: HS.HashSet<A>) => void) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, f: (set: HS.HashSet<A>) => void) => HS.HashSet<A>
>(2, (self, f) => {

@@ -147,4 +147,4 @@ const transient = beginMutation(self)

export const add = Dual.dual<
<A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>,
<A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>
>(

@@ -160,4 +160,4 @@ 2,

export const remove = Dual.dual<
<A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>,
<A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>
>(

@@ -173,4 +173,4 @@ 2,

export const difference = Dual.dual<
<A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>,
<A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>
>(2, (self, that) =>

@@ -185,4 +185,4 @@ mutate(self, (set) => {

export const intersection = Dual.dual<
<A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>,
<A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>
>(2, (self, that) =>

@@ -199,4 +199,4 @@ mutate(empty(), (set) => {

export const union = Dual.dual<
<A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>,
<A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(that: Iterable<A>) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, that: Iterable<A>) => HS.HashSet<A>
>(2, (self, that) =>

@@ -212,4 +212,4 @@ mutate(empty(), (set) => {

export const toggle = Dual.dual<
<A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>,
<A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>
<A>(value: A) => (self: HS.HashSet<A>) => HS.HashSet<A>,
<A>(self: HS.HashSet<A>, value: A) => HS.HashSet<A>
>(2, (self, value) => has(self, value) ? remove(self, value) : add(self, value))

@@ -219,4 +219,4 @@

export const map = Dual.dual<
<A, B>(self: HS.HashSet<A>, f: (a: A) => B) => HS.HashSet<B>,
<A, B>(f: (a: A) => B) => (self: HS.HashSet<A>) => HS.HashSet<B>
<A, B>(f: (a: A) => B) => (self: HS.HashSet<A>) => HS.HashSet<B>,
<A, B>(self: HS.HashSet<A>, f: (a: A) => B) => HS.HashSet<B>
>(2, (self, f) =>

@@ -234,4 +234,4 @@ mutate(empty(), (set) => {

export const flatMap = Dual.dual<
<A, B>(self: HS.HashSet<A>, f: (a: A) => Iterable<B>) => HS.HashSet<B>,
<A, B>(f: (a: A) => Iterable<B>) => (self: HS.HashSet<A>) => HS.HashSet<B>
<A, B>(f: (a: A) => Iterable<B>) => (self: HS.HashSet<A>) => HS.HashSet<B>,
<A, B>(self: HS.HashSet<A>, f: (a: A) => Iterable<B>) => HS.HashSet<B>
>(2, (self, f) =>

@@ -250,4 +250,4 @@ mutate(empty(), (set) => {

export const forEach = Dual.dual<
<A>(self: HS.HashSet<A>, f: (value: A) => void) => void,
<A>(f: (value: A) => void) => (self: HS.HashSet<A>) => void
<A>(f: (value: A) => void) => (self: HS.HashSet<A>) => void,
<A>(self: HS.HashSet<A>, f: (value: A) => void) => void
>(2, <A>(self: HS.HashSet<A>, f: (value: A) => void) =>

@@ -261,4 +261,4 @@ HM.forEachWithIndex(

export const reduce = Dual.dual<
<A, Z>(self: HS.HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => Z,
<A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: HS.HashSet<A>) => Z
<A, Z>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: HS.HashSet<A>) => Z,
<A, Z>(self: HS.HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => Z
>(3, <A, Z>(self: HS.HashSet<A>, zero: Z, f: (accumulator: Z, value: A) => Z) =>

@@ -274,8 +274,8 @@ HM.reduceWithIndex(

{
<A, B extends A>(f: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
<A>(f: Predicate<A>): (self: HS.HashSet<A>) => HS.HashSet<A>
},
{
<A, B extends A>(self: HS.HashSet<A>, f: Refinement<A, B>): HS.HashSet<B>
<A>(self: HS.HashSet<A>, f: Predicate<A>): HS.HashSet<A>
},
{
<A, B extends A>(f: Refinement<A, B>): (self: HS.HashSet<A>) => HS.HashSet<B>
<A>(f: Predicate<A>): (self: HS.HashSet<A>) => HS.HashSet<A>
}

@@ -299,17 +299,17 @@ >(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {

<A, B extends A>(
self: HS.HashSet<A>,
f: Refinement<A, B>
): readonly [HS.HashSet<A>, HS.HashSet<B>]
): (self: HS.HashSet<A>) => readonly [HS.HashSet<A>, HS.HashSet<B>]
<A>(
self: HS.HashSet<A>,
f: Predicate<A>
): readonly [HS.HashSet<A>, HS.HashSet<A>]
): (self: HS.HashSet<A>) => readonly [HS.HashSet<A>, HS.HashSet<A>]
},
{
<A, B extends A>(
self: HS.HashSet<A>,
f: Refinement<A, B>
): (self: HS.HashSet<A>) => readonly [HS.HashSet<A>, HS.HashSet<B>]
): readonly [HS.HashSet<A>, HS.HashSet<B>]
<A>(
self: HS.HashSet<A>,
f: Predicate<A>
): (self: HS.HashSet<A>) => readonly [HS.HashSet<A>, HS.HashSet<A>]
): readonly [HS.HashSet<A>, HS.HashSet<A>]
}

@@ -316,0 +316,0 @@ >(2, <A>(self: HS.HashSet<A>, f: Predicate<A>) => {

90

src/internal/RedBlackTree.ts
import * as Chunk from "@effect/data/Chunk"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"

@@ -9,2 +8,3 @@ import * as Hash from "@effect/data/Hash"

import type * as RBT from "@effect/data/RedBlackTree"
import * as Dual from "@fp-ts/core/Function"
import * as Option from "@fp-ts/core/Option"

@@ -100,4 +100,4 @@ import type * as Ordering from "@fp-ts/core/Ordering"

export const atBackwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Iterable<readonly [K, V]>,
(index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
(index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Iterable<readonly [K, V]>
>(2, (self, index) => at(self, index, Direction.Backward))

@@ -107,4 +107,4 @@

export const atForwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Iterable<readonly [K, V]>,
(index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
(index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Iterable<readonly [K, V]>
>(2, (self, index) => at(self, index, Direction.Forward))

@@ -153,4 +153,4 @@

export const find = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Chunk.Chunk<V>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Chunk.Chunk<V>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Chunk.Chunk<V>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Chunk.Chunk<V>
>(2, <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => {

@@ -176,4 +176,4 @@ const cmp = (self as RedBlackTreeImpl<K, V>)._ord.compare

export const findFirst = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Option.Option<V>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Option.Option<V>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Option.Option<V>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Option.Option<V>
>(2, <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => {

@@ -209,4 +209,4 @@ const cmp = (self as RedBlackTreeImpl<K, V>)._ord.compare

export const getAt = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Option.Option<readonly [K, V]>,
(index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Option.Option<readonly [K, V]>
(index: number) => <K, V>(self: RBT.RedBlackTree<K, V>) => Option.Option<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, index: number) => Option.Option<readonly [K, V]>
>(2, <K, V>(self: RBT.RedBlackTree<K, V>, index: number) => {

@@ -248,4 +248,4 @@ if (index < 0) {

export const has = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => boolean,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => boolean
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => boolean,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => boolean
>(2, (self, key) => Option.isSome(findFirst(self, key)))

@@ -255,4 +255,4 @@

export const insert = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K, value: V) => RBT.RedBlackTree<K, V>,
<K, V>(key: K, value: V) => (self: RBT.RedBlackTree<K, V>) => RBT.RedBlackTree<K, V>
<K, V>(key: K, value: V) => (self: RBT.RedBlackTree<K, V>) => RBT.RedBlackTree<K, V>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K, value: V) => RBT.RedBlackTree<K, V>
>(3, <K, V>(self: RBT.RedBlackTree<K, V>, key: K, value: V) => {

@@ -489,4 +489,4 @@ const cmp = (self as RedBlackTreeImpl<K, V>)._ord.compare

export const greaterThanBackwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => greaterThan(self, key, Direction.Backward))

@@ -496,4 +496,4 @@

export const greaterThanForwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => greaterThan(self, key, Direction.Forward))

@@ -532,4 +532,4 @@

export const greaterThanEqualBackwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => greaterThanEqual(self, key, Direction.Backward))

@@ -539,4 +539,4 @@

export const greaterThanEqualForwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => greaterThanEqual(self, key, Direction.Forward))

@@ -575,4 +575,4 @@

export const lessThanBackwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => lessThan(self, key, Direction.Backward))

@@ -582,4 +582,4 @@

export const lessThanForwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => lessThan(self, key, Direction.Forward))

@@ -618,4 +618,4 @@

export const lessThanEqualBackwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => lessThanEqual(self, key, Direction.Backward))

@@ -625,4 +625,4 @@

export const lessThanEqualForwards = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => Iterable<readonly [K, V]>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => Iterable<readonly [K, V]>
>(2, (self, key) => lessThanEqual(self, key, Direction.Forward))

@@ -661,4 +661,4 @@

export const forEach = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, f: (key: K, value: V) => void) => void,
<K, V>(f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void
<K, V>(f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
<K, V>(self: RBT.RedBlackTree<K, V>, f: (key: K, value: V) => void) => void
>(2, <K, V>(self: RBT.RedBlackTree<K, V>, f: (key: K, value: V) => void) => {

@@ -676,4 +676,4 @@ const root = (self as RedBlackTreeImpl<K, V>)._root

export const forEachGreaterThanEqual = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void) => void,
<K, V>(min: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void
<K, V>(min: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
<K, V>(self: RBT.RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void) => void
>(3, <K, V>(self: RBT.RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void) => {

@@ -692,4 +692,4 @@ const root = (self as RedBlackTreeImpl<K, V>)._root

export const forEachLessThan = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void) => void,
<K, V>(max: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void
<K, V>(max: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
<K, V>(self: RBT.RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void) => void
>(3, <K, V>(self: RBT.RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void) => {

@@ -708,4 +708,4 @@ const root = (self as RedBlackTreeImpl<K, V>)._root

export const forEachBetween = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, min: K, max: K, f: (key: K, value: V) => void) => void,
<K, V>(min: K, max: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void
<K, V>(min: K, max: K, f: (key: K, value: V) => void) => (self: RBT.RedBlackTree<K, V>) => void,
<K, V>(self: RBT.RedBlackTree<K, V>, min: K, max: K, f: (key: K, value: V) => void) => void
>(4, <K, V>(self: RBT.RedBlackTree<K, V>, min: K, max: K, f: (key: K, value: V) => void) => {

@@ -724,4 +724,4 @@ const root = (self as RedBlackTreeImpl<K, V>)._root

export const reduce = Dual.dual<
<Z, K, V>(self: RBT.RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V) => Z) => Z,
<Z, V>(zero: Z, f: (accumulator: Z, value: V) => Z) => <K>(self: RBT.RedBlackTree<K, V>) => Z
<Z, V>(zero: Z, f: (accumulator: Z, value: V) => Z) => <K>(self: RBT.RedBlackTree<K, V>) => Z,
<Z, K, V>(self: RBT.RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V) => Z) => Z
>(3, (self, zero, f) =>

@@ -736,7 +736,7 @@ reduceWithIndex(

export const reduceWithIndex = Dual.dual<
<Z, V, K>(self: RBT.RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => Z,
<Z, V, K>(
zero: Z,
f: (accumulator: Z, value: V, key: K) => Z
) => (self: RBT.RedBlackTree<K, V>) => Z
) => (self: RBT.RedBlackTree<K, V>) => Z,
<Z, V, K>(self: RBT.RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z) => Z
>(3, (self, zero, f) => {

@@ -752,4 +752,4 @@ let accumulator = zero

export const removeFirst = Dual.dual<
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => RBT.RedBlackTree<K, V>,
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => RBT.RedBlackTree<K, V>
<K>(key: K) => <V>(self: RBT.RedBlackTree<K, V>) => RBT.RedBlackTree<K, V>,
<K, V>(self: RBT.RedBlackTree<K, V>, key: K) => RBT.RedBlackTree<K, V>
>(2, <K, V>(self: RBT.RedBlackTree<K, V>, key: K) => {

@@ -756,0 +756,0 @@ if (!has(self, key)) {

130

src/List.ts

@@ -16,6 +16,6 @@ /**

import * as Chunk from "@effect/data/Chunk"
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as Either from "@fp-ts/core/Either"
import * as Dual from "@fp-ts/core/Function"
import { identity, unsafeCoerce } from "@fp-ts/core/Function"

@@ -234,7 +234,7 @@ import * as Option from "@fp-ts/core/Option"

export const equalsWith: {
<A, B>(that: List<B>, f: (a: A, b: B) => boolean): (self: List<A>) => boolean
<A, B>(self: List<A>, that: List<B>, f: (a: A, b: B) => boolean): boolean
<A, B>(that: List<B>, f: (a: A, b: B) => boolean): (self: List<A>) => boolean
} = Dual.dual<
<A, B>(self: List<A>, that: List<B>, f: (a: A, b: B) => boolean) => boolean,
<A, B>(that: List<B>, f: (a: A, b: B) => boolean) => (self: List<A>) => boolean
<A, B>(that: List<B>, f: (a: A, b: B) => boolean) => (self: List<A>) => boolean,
<A, B>(self: List<A>, that: List<B>, f: (a: A, b: B) => boolean) => boolean
>(3, <A, B>(self: List<A>, that: List<B>, f: (a: A, b: B) => boolean) => {

@@ -344,7 +344,7 @@ if ((self as List<A | B>) === that) {

export const concat: {
<B>(that: List<B>): <A>(self: List<A>) => List<A | B>
<A, B>(self: List<A>, that: List<B>): List<A | B>
<B>(that: List<B>): <A>(self: List<A>) => List<A | B>
} = Dual.dual<
<A, B>(self: List<A>, that: List<B>) => List<A | B>,
<B>(that: List<B>) => <A>(self: List<A>) => List<A | B>
<B>(that: List<B>) => <A>(self: List<A>) => List<A | B>,
<A, B>(self: List<A>, that: List<B>) => List<A | B>
>(2, (self, that) => prependAll(that, self))

@@ -359,7 +359,7 @@

export const drop: {
(n: number): <A>(self: List<A>) => List<A>
<A>(self: List<A>, n: number): List<A>
(n: number): <A>(self: List<A>) => List<A>
} = Dual.dual<
<A>(self: List<A>, n: number) => List<A>,
(n: number) => <A>(self: List<A>) => List<A>
(n: number) => <A>(self: List<A>) => List<A>,
<A>(self: List<A>, n: number) => List<A>
>(2, (self, n) => {

@@ -389,7 +389,7 @@ if (n <= 0) {

export const every: {
<A>(predicate: Predicate<A>): (self: List<A>) => boolean
<A>(self: List<A>, predicate: Predicate<A>): boolean
<A>(predicate: Predicate<A>): (self: List<A>) => boolean
} = Dual.dual<
<A>(self: List<A>, predicate: Predicate<A>) => boolean,
<A>(predicate: Predicate<A>) => (self: List<A>) => boolean
<A>(predicate: Predicate<A>) => (self: List<A>) => boolean,
<A>(self: List<A>, predicate: Predicate<A>) => boolean
>(2, (self, predicate) => {

@@ -411,12 +411,12 @@ for (const a of self) {

export const filter: {
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>
<A>(predicate: Predicate<A>): (self: List<A>) => List<A>
<A, B extends A>(self: List<A>, refinement: Refinement<A, B>): List<B>
<A>(self: List<A>, predicate: Predicate<A>): List<A>
} = Dual.dual<{
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>
<A>(predicate: Predicate<A>): (self: List<A>) => List<A>
} = Dual.dual<{
}, {
<A, B extends A>(self: List<A>, refinement: Refinement<A, B>): List<B>
<A>(self: List<A>, predicate: Predicate<A>): List<A>
}, {
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => List<B>
<A>(predicate: Predicate<A>): (self: List<A>) => List<A>
}>(2, <A>(self: List<A>, predicate: Predicate<A>) => noneIn(self, predicate, false))

@@ -433,7 +433,7 @@

export const filterMap: {
<A, B>(pf: (a: A) => Option.Option<B>): (self: Iterable<A>) => List<B>
<A, B>(self: Iterable<A>, pf: (a: A) => Option.Option<B>): List<B>
<A, B>(pf: (a: A) => Option.Option<B>): (self: Iterable<A>) => List<B>
} = Dual.dual<
<A, B>(self: Iterable<A>, pf: (a: A) => Option.Option<B>) => List<B>,
<A, B>(pf: (a: A) => Option.Option<B>) => (self: Iterable<A>) => List<B>
<A, B>(pf: (a: A) => Option.Option<B>) => (self: Iterable<A>) => List<B>,
<A, B>(self: Iterable<A>, pf: (a: A) => Option.Option<B>) => List<B>
>(2, <A, B>(self: Iterable<A>, pf: (a: A) => Option.Option<B>) => {

@@ -458,14 +458,14 @@ const bs: Array<B> = []

export const findFirst: {
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
<A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>
<A, B extends A>(self: List<A>, refinement: Refinement<A, B>): Option.Option<B>
<A>(self: List<A>, predicate: Predicate<A>): Option.Option<A>
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
<A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>
} = Dual.dual<
{
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
<A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>
},
{
<A, B extends A>(self: List<A>, refinement: Refinement<A, B>): Option.Option<B>
<A>(self: List<A>, predicate: Predicate<A>): Option.Option<A>
},
{
<A, B extends A>(refinement: Refinement<A, B>): (self: List<A>) => Option.Option<B>
<A>(predicate: Predicate<A>): (self: List<A>) => Option.Option<A>
}

@@ -490,7 +490,7 @@ >(2, <A>(self: List<A>, predicate: Predicate<A>) => {

export const flatMap: {
<A, B>(f: (a: A) => List<B>): (self: List<A>) => List<B>
<A, B>(self: List<A>, f: (a: A) => List<B>): List<B>
<A, B>(f: (a: A) => List<B>): (self: List<A>) => List<B>
} = Dual.dual<
<A, B>(self: List<A>, f: (a: A) => List<B>) => List<B>,
<A, B>(f: (a: A) => List<B>) => (self: List<A>) => List<B>
<A, B>(f: (a: A) => List<B>) => (self: List<A>) => List<B>,
<A, B>(self: List<A>, f: (a: A) => List<B>) => List<B>
>(2, <A, B>(self: List<A>, f: (a: A) => List<B>) => {

@@ -527,7 +527,7 @@ let rest = self

export const forEach: {
<A, B>(f: (a: A) => B): (self: List<A>) => void
<A, B>(self: List<A>, f: (a: A) => B): void
<A, B>(f: (a: A) => B): (self: List<A>) => void
} = Dual.dual<
<A, B>(self: List<A>, f: (a: A) => B) => void,
<A, B>(f: (a: A) => B) => (self: List<A>) => void
<A, B>(f: (a: A) => B) => (self: List<A>) => void,
<A, B>(self: List<A>, f: (a: A) => B) => void
>(2, (self, f) => {

@@ -566,7 +566,7 @@ let these = self

export const map: {
<A, B>(f: (a: A) => B): (self: List<A>) => List<B>
<A, B>(self: List<A>, f: (a: A) => B): List<B>
<A, B>(f: (a: A) => B): (self: List<A>) => List<B>
} = Dual.dual<
<A, B>(self: List<A>, f: (a: A) => B) => List<B>,
<A, B>(f: (a: A) => B) => (self: List<A>) => List<B>
<A, B>(f: (a: A) => B) => (self: List<A>) => List<B>,
<A, B>(self: List<A>, f: (a: A) => B) => List<B>
>(2, <A, B>(self: List<A>, f: (a: A) => B) => {

@@ -598,7 +598,7 @@ if (isNil(self)) {

export const partition: {
<A>(predicate: Predicate<A>): (self: List<A>) => readonly [List<A>, List<A>]
<A>(self: List<A>, predicate: Predicate<A>): readonly [List<A>, List<A>]
<A>(predicate: Predicate<A>): (self: List<A>) => readonly [List<A>, List<A>]
} = Dual.dual<
<A>(self: List<A>, predicate: Predicate<A>) => readonly [List<A>, List<A>],
<A>(predicate: Predicate<A>) => (self: List<A>) => readonly [List<A>, List<A>]
<A>(predicate: Predicate<A>) => (self: List<A>) => readonly [List<A>, List<A>],
<A>(self: List<A>, predicate: Predicate<A>) => readonly [List<A>, List<A>]
>(2, <A>(self: List<A>, predicate: Predicate<A>) => {

@@ -626,7 +626,7 @@ const left: Array<A> = []

export const partitionMap: {
<A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => readonly [List<B>, List<C>]
<A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>): readonly [List<B>, List<C>]
<A, B, C>(f: (a: A) => Either.Either<B, C>): (self: List<A>) => readonly [List<B>, List<C>]
} = Dual.dual<
<A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>) => readonly [List<B>, List<C>],
<A, B, C>(f: (a: A) => Either.Either<B, C>) => (self: List<A>) => readonly [List<B>, List<C>]
<A, B, C>(f: (a: A) => Either.Either<B, C>) => (self: List<A>) => readonly [List<B>, List<C>],
<A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>) => readonly [List<B>, List<C>]
>(2, <A, B, C>(self: List<A>, f: (a: A) => Either.Either<B, C>) => {

@@ -653,7 +653,7 @@ const left: Array<B> = []

export const prepend: {
<B>(element: B): <A>(self: List<A>) => Cons<A | B>
<A, B>(self: List<A>, element: B): Cons<A | B>
<B>(element: B): <A>(self: List<A>) => Cons<A | B>
} = Dual.dual<
<A, B>(self: List<A>, element: B) => Cons<A | B>,
<B>(element: B) => <A>(self: List<A>) => Cons<A | B>
<B>(element: B) => <A>(self: List<A>) => Cons<A | B>,
<A, B>(self: List<A>, element: B) => Cons<A | B>
>(2, <A, B>(self: List<A>, element: B) => cons<A | B>(element, self))

@@ -668,7 +668,7 @@

export const prependAll: {
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>
<A, B>(self: List<A>, prefix: List<B>): List<A | B>
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>
} = Dual.dual<
<A, B>(self: List<A>, prefix: List<B>) => List<A | B>,
<B>(prefix: List<B>) => <A>(self: List<A>) => List<A | B>
<B>(prefix: List<B>) => <A>(self: List<A>) => List<A | B>,
<A, B>(self: List<A>, prefix: List<B>) => List<A | B>
>(2, <A, B>(self: List<A>, prefix: List<B>) => {

@@ -701,7 +701,7 @@ if (isNil(self)) {

export const prependAllReversed: {
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>
<A, B>(self: List<A>, prefix: List<B>): List<A | B>
<B>(prefix: List<B>): <A>(self: List<A>) => List<A | B>
} = Dual.dual<
<A, B>(self: List<A>, prefix: List<B>) => List<A | B>,
<B>(prefix: List<B>) => <A>(self: List<A>) => List<A | B>
<B>(prefix: List<B>) => <A>(self: List<A>) => List<A | B>,
<A, B>(self: List<A>, prefix: List<B>) => List<A | B>
>(2, <A, B>(self: List<A>, prefix: List<B>) => {

@@ -725,7 +725,7 @@ let these: List<A | B> = self

export const reduce: {
<Z, A>(zero: Z, f: (b: Z, a: A) => Z): (self: List<A>) => Z
<A, Z>(self: List<A>, zero: Z, f: (b: Z, a: A) => Z): Z
<Z, A>(zero: Z, f: (b: Z, a: A) => Z): (self: List<A>) => Z
} = Dual.dual<
<A, Z>(self: List<A>, zero: Z, f: (b: Z, a: A) => Z) => Z,
<Z, A>(zero: Z, f: (b: Z, a: A) => Z) => (self: List<A>) => Z
<Z, A>(zero: Z, f: (b: Z, a: A) => Z) => (self: List<A>) => Z,
<A, Z>(self: List<A>, zero: Z, f: (b: Z, a: A) => Z) => Z
>(3, (self, zero, f) => {

@@ -749,7 +749,7 @@ let acc = zero

export const reduceRight: {
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: List<A>) => Z
<Z, A>(self: List<A>, zero: Z, f: (accumulator: Z, value: A) => Z): Z
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z): (self: List<A>) => Z
} = Dual.dual<
<Z, A>(self: List<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => Z,
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: List<A>) => Z
<Z, A>(zero: Z, f: (accumulator: Z, value: A) => Z) => (self: List<A>) => Z,
<Z, A>(self: List<A>, zero: Z, f: (accumulator: Z, value: A) => Z) => Z
>(3, (self, zero, f) => {

@@ -789,7 +789,7 @@ let acc = zero

export const some: {
<A>(predicate: Predicate<A>): (self: List<A>) => boolean
<A>(self: List<A>, predicate: Predicate<A>): boolean
<A>(predicate: Predicate<A>): (self: List<A>) => boolean
} = Dual.dual<
<A>(self: List<A>, predicate: Predicate<A>) => boolean,
<A>(predicate: Predicate<A>) => (self: List<A>) => boolean
<A>(predicate: Predicate<A>) => (self: List<A>) => boolean,
<A>(self: List<A>, predicate: Predicate<A>) => boolean
>(2, (self, predicate) => {

@@ -813,7 +813,7 @@ let these = self

export const splitAt: {
(n: number): <A>(self: List<A>) => readonly [List<A>, List<A>]
<A>(self: List<A>, n: number): readonly [List<A>, List<A>]
(n: number): <A>(self: List<A>) => readonly [List<A>, List<A>]
} = Dual.dual<
<A>(self: List<A>, n: number) => readonly [List<A>, List<A>],
(n: number) => <A>(self: List<A>) => readonly [List<A>, List<A>]
(n: number) => <A>(self: List<A>) => readonly [List<A>, List<A>],
<A>(self: List<A>, n: number) => readonly [List<A>, List<A>]
>(2, (self, n) => [take(self, n), drop(self, n)])

@@ -837,7 +837,7 @@

export const take: {
(n: number): <A>(self: List<A>) => List<A>
<A>(self: List<A>, n: number): List<A>
(n: number): <A>(self: List<A>) => List<A>
} = Dual.dual<
<A>(self: List<A>, n: number) => List<A>,
(n: number) => <A>(self: List<A>) => List<A>
(n: number) => <A>(self: List<A>) => List<A>,
<A>(self: List<A>, n: number) => List<A>
>(2, (self, n) => {

@@ -844,0 +844,0 @@ if (n <= 0) {

51

src/MutableHashMap.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as Dual from "@fp-ts/core/Function"
import * as Option from "@fp-ts/core/Option"

@@ -130,7 +130,7 @@

export const get: {
<K>(key: K): <V>(self: MutableHashMap<K, V>) => Option.Option<V>
<K, V>(self: MutableHashMap<K, V>, key: K): Option.Option<V>
<K>(key: K): <V>(self: MutableHashMap<K, V>) => Option.Option<V>
} = Dual.dual<
<K, V>(self: MutableHashMap<K, V>, key: K) => Option.Option<V>,
<K>(key: K) => <V>(self: MutableHashMap<K, V>) => Option.Option<V>
<K>(key: K) => <V>(self: MutableHashMap<K, V>) => Option.Option<V>,
<K, V>(self: MutableHashMap<K, V>, key: K) => Option.Option<V>
>(2, <K, V>(self: MutableHashMap<K, V>, key: K) => {

@@ -157,7 +157,7 @@ const hash = Hash.hash(key)

export const has: {
<K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean
<K, V>(self: MutableHashMap<K, V>, key: K): boolean
<K>(key: K): <V>(self: MutableHashMap<K, V>) => boolean
} = Dual.dual<
<K, V>(self: MutableHashMap<K, V>, key: K) => boolean,
<K>(key: K) => <V>(self: MutableHashMap<K, V>) => boolean
<K>(key: K) => <V>(self: MutableHashMap<K, V>) => boolean,
<K, V>(self: MutableHashMap<K, V>, key: K) => boolean
>(2, (self, key) => Option.isSome(get(self, key)))

@@ -172,7 +172,7 @@

export const modify: {
<K, V>(key: K, f: (v: V) => V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V): MutableHashMap<K, V>
<K, V>(key: K, f: (v: V) => V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
} = Dual.dual<
<K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => MutableHashMap<K, V>,
<K, V>(key: K, f: (v: V) => V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K, V>(key: K, f: (v: V) => V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
<K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => MutableHashMap<K, V>
>(3, <K, V>(self: MutableHashMap<K, V>, key: K, f: (v: V) => V) => {

@@ -203,24 +203,13 @@ const hash = Hash.hash(key)

export const modifyAt: {
<K, V>(key: K, f: (value: Option.Option<V>) => Option.Option<V>): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K, V>(self: MutableHashMap<K, V>, key: K, f: (value: Option.Option<V>) => Option.Option<V>): MutableHashMap<K, V>
} = Dual.dual<
<K, V>(
self: MutableHashMap<K, V>,
key: K,
f: (value: Option.Option<V>) => Option.Option<V>
): MutableHashMap<K, V>
) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
<K, V>(
key: K,
f: (value: Option.Option<V>) => Option.Option<V>
): (
self: MutableHashMap<K, V>
) => MutableHashMap<K, V>
} = Dual.dual<
<K, V>(
self: MutableHashMap<K, V>,
key: K,
f: (value: Option.Option<V>) => Option.Option<V>
) => MutableHashMap<K, V>,
<K, V>(
key: K,
f: (value: Option.Option<V>) => Option.Option<V>
) => (
self: MutableHashMap<K, V>
) => MutableHashMap<K, V>

@@ -242,7 +231,7 @@ >(3, (self, key, f) => {

export const remove: {
<K>(key: K): <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K, V>(self: MutableHashMap<K, V>, key: K): MutableHashMap<K, V>
<K>(key: K): <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>
} = Dual.dual<
<K, V>(self: MutableHashMap<K, V>, key: K) => MutableHashMap<K, V>,
<K>(key: K) => <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K>(key: K) => <V>(self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
<K, V>(self: MutableHashMap<K, V>, key: K) => MutableHashMap<K, V>
>(2, <K, V>(self: MutableHashMap<K, V>, key: K) => {

@@ -282,7 +271,7 @@ const hash = Hash.hash(key)

export const set: {
<K, V>(key: K, value: V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K, V>(self: MutableHashMap<K, V>, key: K, value: V): MutableHashMap<K, V>
<K, V>(key: K, value: V): (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
} = Dual.dual<
<K, V>(self: MutableHashMap<K, V>, key: K, value: V) => MutableHashMap<K, V>,
<K, V>(key: K, value: V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>
<K, V>(key: K, value: V) => (self: MutableHashMap<K, V>) => MutableHashMap<K, V>,
<K, V>(self: MutableHashMap<K, V>, key: K, value: V) => MutableHashMap<K, V>
>(3, <K, V>(self: MutableHashMap<K, V>, key: K, value: V) => {

@@ -289,0 +278,0 @@ const hash = Hash.hash(key)

20

src/MutableHashSet.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as MutableHashMap from "@effect/data/MutableHashMap"
import * as Dual from "@fp-ts/core/Function"

@@ -84,7 +84,7 @@ const TypeId: unique symbol = Symbol.for("@effect/data/MutableHashSet") as TypeId

export const add: {
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>
<V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>
} = Dual.dual<
<V>(self: MutableHashSet<V>, key: V) => MutableHashSet<V>,
<V>(key: V) => (self: MutableHashSet<V>) => MutableHashSet<V>
<V>(key: V) => (self: MutableHashSet<V>) => MutableHashSet<V>,
<V>(self: MutableHashSet<V>, key: V) => MutableHashSet<V>
>(2, (self, key) => (MutableHashMap.set(self.keyMap, key, true), self))

@@ -97,7 +97,7 @@

export const has: {
<V>(key: V): (self: MutableHashSet<V>) => boolean
<V>(self: MutableHashSet<V>, key: V): boolean
<V>(key: V): (self: MutableHashSet<V>) => boolean
} = Dual.dual<
<V>(self: MutableHashSet<V>, key: V) => boolean,
<V>(key: V) => (self: MutableHashSet<V>) => boolean
<V>(key: V) => (self: MutableHashSet<V>) => boolean,
<V>(self: MutableHashSet<V>, key: V) => boolean
>(2, (self, key) => MutableHashMap.has(self.keyMap, key))

@@ -110,7 +110,7 @@

export const remove: {
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>
<V>(self: MutableHashSet<V>, key: V): MutableHashSet<V>
<V>(key: V): (self: MutableHashSet<V>) => MutableHashSet<V>
} = Dual.dual<
<V>(self: MutableHashSet<V>, key: V) => MutableHashSet<V>,
<V>(key: V) => (self: MutableHashSet<V>) => MutableHashSet<V>
<V>(key: V) => (self: MutableHashSet<V>) => MutableHashSet<V>,
<V>(self: MutableHashSet<V>, key: V) => MutableHashSet<V>
>(2, (self, key) => (MutableHashMap.remove(self.keyMap, key), self))

@@ -117,0 +117,0 @@

14

src/MutableList.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Dual from "@fp-ts/core/Function"

@@ -153,7 +153,7 @@ const TypeId: unique symbol = Symbol.for("@effect/data/MutableList") as TypeId

export const forEach: {
<A>(f: (element: A) => void): (self: MutableList<A>) => void
<A>(self: MutableList<A>, f: (element: A) => void): void
<A>(f: (element: A) => void): (self: MutableList<A>) => void
} = Dual.dual<
<A>(self: MutableList<A>, f: (element: A) => void) => void,
<A>(f: (element: A) => void) => (self: MutableList<A>) => void
<A>(f: (element: A) => void) => (self: MutableList<A>) => void,
<A>(self: MutableList<A>, f: (element: A) => void) => void
>(2, (self, f) => {

@@ -187,7 +187,7 @@ let current = self.head

export const append: {
<A>(value: A): (self: MutableList<A>) => MutableList<A>
<A>(self: MutableList<A>, value: A): MutableList<A>
<A>(value: A): (self: MutableList<A>) => MutableList<A>
} = Dual.dual<
<A>(self: MutableList<A>, value: A) => MutableList<A>,
<A>(value: A) => (self: MutableList<A>) => MutableList<A>
<A>(value: A) => (self: MutableList<A>) => MutableList<A>,
<A>(self: MutableList<A>, value: A) => MutableList<A>
>(2, <A>(self: MutableList<A>, value: A) => {

@@ -194,0 +194,0 @@ const node = new LinkedListNode(value)

24

src/MutableQueue.ts

@@ -5,4 +5,4 @@ /**

import * as Chunk from "@effect/data/Chunk"
import * as Dual from "@effect/data/Dual"
import * as MutableList from "@effect/data/MutableList"
import * as Dual from "@fp-ts/core/Function"

@@ -136,4 +136,4 @@ const TypeId: unique symbol = Symbol.for("@effect/data/MutableQueue") as TypeId

} = Dual.dual<
<A>(self: MutableQueue<A>, value: A) => boolean,
<A>(value: A) => (self: MutableQueue<A>) => boolean
<A>(value: A) => (self: MutableQueue<A>) => boolean,
<A>(self: MutableQueue<A>, value: A) => boolean
>(2, <A>(self: MutableQueue<A>, value: A) => {

@@ -157,7 +157,7 @@ const queueLength = MutableList.length((self as MutableQueueImpl<A>).queue)

export const offerAll: {
<A>(values: Iterable<A>): (self: MutableQueue<A>) => Chunk.Chunk<A>
<A>(self: MutableQueue<A>, values: Iterable<A>): Chunk.Chunk<A>
<A>(values: Iterable<A>): (self: MutableQueue<A>) => Chunk.Chunk<A>
} = Dual.dual<
<A>(self: MutableQueue<A>, values: Iterable<A>) => Chunk.Chunk<A>,
<A>(values: Iterable<A>) => (self: MutableQueue<A>) => Chunk.Chunk<A>
<A>(values: Iterable<A>) => (self: MutableQueue<A>) => Chunk.Chunk<A>,
<A>(self: MutableQueue<A>, values: Iterable<A>) => Chunk.Chunk<A>
>(2, <A>(self: MutableQueue<A>, values: Iterable<A>) => {

@@ -190,7 +190,7 @@ const iterator = values[Symbol.iterator]()

export const poll: {
<D>(def: D): <A>(self: MutableQueue<A>) => D | A
<A, D>(self: MutableQueue<A>, def: D): A | D
<D>(def: D): <A>(self: MutableQueue<A>) => D | A
} = Dual.dual<
<A, D>(self: MutableQueue<A>, def: D) => A | D,
<D>(def: D) => <A>(self: MutableQueue<A>) => A | D
<D>(def: D) => <A>(self: MutableQueue<A>) => A | D,
<A, D>(self: MutableQueue<A>, def: D) => A | D
>(2, (self, def) => {

@@ -212,7 +212,7 @@ if (MutableList.isEmpty(self.queue)) {

export const pollUpTo: {
(n: number): <A>(self: MutableQueue<A>) => Chunk.Chunk<A>
<A>(self: MutableQueue<A>, n: number): Chunk.Chunk<A>
(n: number): <A>(self: MutableQueue<A>) => Chunk.Chunk<A>
} = Dual.dual<
<A>(self: MutableQueue<A>, n: number) => Chunk.Chunk<A>,
(n: number) => <A>(self: MutableQueue<A>) => Chunk.Chunk<A>
(n: number) => <A>(self: MutableQueue<A>) => Chunk.Chunk<A>,
<A>(self: MutableQueue<A>, n: number) => Chunk.Chunk<A>
>(2, <A>(self: MutableQueue<A>, n: number) => {

@@ -219,0 +219,0 @@ let result = Chunk.empty<A>()

44

src/MutableRef.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Dual from "@fp-ts/core/Function"

@@ -158,7 +158,7 @@ const TypeId: unique symbol = Symbol.for("@effect/data/MutableRef") as TypeId

export const compareAndSet: {
<T>(oldValue: T, newValue: T): (self: MutableRef<T>) => boolean
<T>(self: MutableRef<T>, oldValue: T, newValue: T): boolean
<T>(oldValue: T, newValue: T): (self: MutableRef<T>) => boolean
} = Dual.dual<
<T>(self: MutableRef<T>, oldValue: T, newValue: T) => boolean,
<T>(oldValue: T, newValue: T) => (self: MutableRef<T>) => boolean
<T>(oldValue: T, newValue: T) => (self: MutableRef<T>) => boolean,
<T>(self: MutableRef<T>, oldValue: T, newValue: T) => boolean
>(3, (self, oldValue, newValue) => self.compareAndSet(oldValue, newValue))

@@ -201,7 +201,7 @@

export const getAndSet: {
<T>(value: T): (self: MutableRef<T>) => T
<T>(self: MutableRef<T>, value: T): T
<T>(value: T): (self: MutableRef<T>) => T
} = Dual.dual<
<T>(self: MutableRef<T>, value: T) => T,
<T>(value: T) => (self: MutableRef<T>) => T
<T>(value: T) => (self: MutableRef<T>) => T,
<T>(self: MutableRef<T>, value: T) => T
>(2, (self, value) => self.getAndSet(value))

@@ -214,7 +214,7 @@

export const getAndUpdate: {
<T>(f: (value: T) => T): (self: MutableRef<T>) => T
<T>(self: MutableRef<T>, f: (value: T) => T): T
<T>(f: (value: T) => T): (self: MutableRef<T>) => T
} = Dual.dual<
<T>(self: MutableRef<T>, f: (value: T) => T) => T,
<T>(f: (value: T) => T) => (self: MutableRef<T>) => T
<T>(f: (value: T) => T) => (self: MutableRef<T>) => T,
<T>(self: MutableRef<T>, f: (value: T) => T) => T
>(2, (self, f) => self.getAndUpdate(f))

@@ -239,7 +239,7 @@

export const set: {
<T>(value: T): (self: MutableRef<T>) => MutableRef<T>
<T>(self: MutableRef<T>, value: T): MutableRef<T>
<T>(value: T): (self: MutableRef<T>) => MutableRef<T>
} = Dual.dual<
<T>(self: MutableRef<T>, value: T) => MutableRef<T>,
<T>(value: T) => (self: MutableRef<T>) => MutableRef<T>
<T>(value: T) => (self: MutableRef<T>) => MutableRef<T>,
<T>(self: MutableRef<T>, value: T) => MutableRef<T>
>(2, (self, value) => self.set(value))

@@ -252,7 +252,7 @@

export const setAndGet: {
<T>(value: T): (self: MutableRef<T>) => T
<T>(self: MutableRef<T>, value: T): T
<T>(value: T): (self: MutableRef<T>) => T
} = Dual.dual<
<T>(self: MutableRef<T>, value: T) => T,
<T>(value: T) => (self: MutableRef<T>) => T
<T>(value: T) => (self: MutableRef<T>) => T,
<T>(self: MutableRef<T>, value: T) => T
>(2, (self, value) => self.setAndGet(value))

@@ -265,7 +265,7 @@

export const update: {
<T>(f: (value: T) => T): (self: MutableRef<T>) => MutableRef<T>
<T>(self: MutableRef<T>, f: (value: T) => T): MutableRef<T>
<T>(f: (value: T) => T): (self: MutableRef<T>) => MutableRef<T>
} = Dual.dual<
<T>(self: MutableRef<T>, f: (value: T) => T) => MutableRef<T>,
<T>(f: (value: T) => T) => (self: MutableRef<T>) => MutableRef<T>
<T>(f: (value: T) => T) => (self: MutableRef<T>) => MutableRef<T>,
<T>(self: MutableRef<T>, f: (value: T) => T) => MutableRef<T>
>(2, (self, f) => self.update(f))

@@ -278,7 +278,7 @@

export const updateAndGet: {
<T>(f: (value: T) => T): (self: MutableRef<T>) => T
<T>(self: MutableRef<T>, f: (value: T) => T): T
<T>(f: (value: T) => T): (self: MutableRef<T>) => T
} = Dual.dual<
<T>(self: MutableRef<T>, f: (value: T) => T) => T,
<T>(f: (value: T) => T) => (self: MutableRef<T>) => T
<T>(f: (value: T) => T) => (self: MutableRef<T>) => T,
<T>(self: MutableRef<T>, f: (value: T) => T) => T
>(2, (self, f) => self.updateAndGet(f))

@@ -285,0 +285,0 @@

49

src/RedBlackTree.ts

@@ -67,5 +67,4 @@ /**

*/
export const fromIterable: <K, V>(
ord: Order<K>
) => (entries: Iterable<readonly [K, V]>) => RedBlackTree<K, V> = RBT.fromIterable
export const fromIterable: <K, V>(ord: Order<K>) => (entries: Iterable<readonly [K, V]>) => RedBlackTree<K, V> =
RBT.fromIterable

@@ -94,4 +93,4 @@ /**

export const at: {
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, index: number): Iterable<readonly [K, V]>
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.atForwards

@@ -109,4 +108,4 @@

export const atReversed: {
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, index: number): Iterable<readonly [K, V]>
(index: number): <K, V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.atBackwards

@@ -121,4 +120,4 @@

export const find: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>
<K, V>(self: RedBlackTree<K, V>, key: K): Chunk<V>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Chunk<V>
} = RBT.find

@@ -133,4 +132,4 @@

export const findFirst: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>
<K, V>(self: RedBlackTree<K, V>, key: K): Option<V>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Option<V>
} = RBT.findFirst

@@ -154,4 +153,4 @@

export const getAt: {
(index: number): <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, index: number): Option<readonly [K, V]>
(index: number): <K, V>(self: RedBlackTree<K, V>) => Option<readonly [K, V]>
} = RBT.getAt

@@ -175,4 +174,4 @@

export const greaterThan: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.greaterThanForwards

@@ -188,4 +187,4 @@

export const greaterThanReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.greaterThanBackwards

@@ -201,4 +200,4 @@

export const greaterThanEqual: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.greaterThanEqualForwards

@@ -214,4 +213,4 @@

export const greaterThanEqualReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.greaterThanEqualBackwards

@@ -226,4 +225,4 @@

export const has: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean
<K, V>(self: RedBlackTree<K, V>, key: K): boolean
<K>(key: K): <V>(self: RedBlackTree<K, V>) => boolean
} = RBT.has

@@ -238,4 +237,4 @@

export const insert: {
<K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>
<K, V>(self: RedBlackTree<K, V>, key: K, value: V): RedBlackTree<K, V>
<K, V>(key: K, value: V): (self: RedBlackTree<K, V>) => RedBlackTree<K, V>
} = RBT.insert

@@ -275,4 +274,4 @@

export const lessThan: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.lessThanForwards

@@ -288,4 +287,4 @@

export const lessThanReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.lessThanBackwards

@@ -301,4 +300,4 @@

export const lessThanEqual: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.lessThanEqualForwards

@@ -314,4 +313,4 @@

export const lessThanEqualReversed: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
<K, V>(self: RedBlackTree<K, V>, key: K): Iterable<readonly [K, V]>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => Iterable<readonly [K, V]>
} = RBT.lessThanEqualBackwards

@@ -326,4 +325,4 @@

export const forEach: {
<K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
<K, V>(self: RedBlackTree<K, V>, f: (key: K, value: V) => void): void
<K, V>(f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
} = RBT.forEach

@@ -338,4 +337,4 @@

export const forEachGreaterThanEqual: {
<K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
<K, V>(self: RedBlackTree<K, V>, min: K, f: (key: K, value: V) => void): void
<K, V>(min: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
} = RBT.forEachGreaterThanEqual

@@ -350,4 +349,4 @@

export const forEachLessThan: {
<K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
<K, V>(self: RedBlackTree<K, V>, max: K, f: (key: K, value: V) => void): void
<K, V>(max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
} = RBT.forEachLessThan

@@ -363,4 +362,4 @@

export const forEachBetween: {
<K, V>(min: K, max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
<K, V>(self: RedBlackTree<K, V>, min: K, max: K, f: (key: K, value: V) => void): void
<K, V>(min: K, max: K, f: (key: K, value: V) => void): (self: RedBlackTree<K, V>) => void
} = RBT.forEachBetween

@@ -375,4 +374,4 @@

export const reduce: {
<Z, V>(zero: Z, f: (accumulator: Z, value: V) => Z): <K>(self: RedBlackTree<K, V>) => Z
<Z, K, V>(self: RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V) => Z): Z
<Z, V>(zero: Z, f: (accumulator: Z, value: V) => Z): <K>(self: RedBlackTree<K, V>) => Z
} = RBT.reduce

@@ -387,4 +386,4 @@

export const reduceWithIndex: {
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z
<Z, V, K>(self: RedBlackTree<K, V>, zero: Z, f: (accumulator: Z, value: V, key: K) => Z): Z
<Z, V, K>(zero: Z, f: (accumulator: Z, value: V, key: K) => Z): (self: RedBlackTree<K, V>) => Z
} = RBT.reduceWithIndex

@@ -399,4 +398,4 @@

export const removeFirst: {
<K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>
<K, V>(self: RedBlackTree<K, V>, key: K): RedBlackTree<K, V>
<K>(key: K): <V>(self: RedBlackTree<K, V>) => RedBlackTree<K, V>
} = RBT.removeFirst

@@ -403,0 +402,0 @@

50

src/SortedMap.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as RBT from "@effect/data/RedBlackTree"
import * as Dual from "@fp-ts/core/Function"
import { pipe } from "@fp-ts/core/Function"

@@ -120,7 +120,7 @@ import * as Option from "@fp-ts/core/Option"

export const get: {
<K>(key: K): <V>(self: SortedMap<K, V>) => Option.Option<V>
<K, V>(self: SortedMap<K, V>, key: K): Option.Option<V>
<K>(key: K): <V>(self: SortedMap<K, V>) => Option.Option<V>
} = Dual.dual<
<K, V>(self: SortedMap<K, V>, key: K) => Option.Option<V>,
<K>(key: K) => <V>(self: SortedMap<K, V>) => Option.Option<V>
<K>(key: K) => <V>(self: SortedMap<K, V>) => Option.Option<V>,
<K, V>(self: SortedMap<K, V>, key: K) => Option.Option<V>
>(2, (self, key) => RBT.findFirst(self.tree, key))

@@ -141,7 +141,7 @@

export const has: {
<K>(key: K): <V>(self: SortedMap<K, V>) => boolean
<K, V>(self: SortedMap<K, V>, key: K): boolean
<K>(key: K): <V>(self: SortedMap<K, V>) => boolean
} = Dual.dual<
<K, V>(self: SortedMap<K, V>, key: K) => boolean,
<K>(key: K) => <V>(self: SortedMap<K, V>) => boolean
<K>(key: K) => <V>(self: SortedMap<K, V>) => boolean,
<K, V>(self: SortedMap<K, V>, key: K) => boolean
>(2, (self, key) => Option.isSome(get(self, key)))

@@ -160,7 +160,7 @@

export const map: {
<A, B>(f: (a: A) => B): <K>(self: SortedMap<K, A>) => SortedMap<K, B>
<K, A, B>(self: SortedMap<K, A>, f: (a: A) => B): SortedMap<K, B>
<A, B>(f: (a: A) => B): <K>(self: SortedMap<K, A>) => SortedMap<K, B>
} = Dual.dual<
<K, A, B>(self: SortedMap<K, A>, f: (a: A) => B) => SortedMap<K, B>,
<A, B>(f: (a: A) => B) => <K>(self: SortedMap<K, A>) => SortedMap<K, B>
<A, B>(f: (a: A) => B) => <K>(self: SortedMap<K, A>) => SortedMap<K, B>,
<K, A, B>(self: SortedMap<K, A>, f: (a: A) => B) => SortedMap<K, B>
>(2, (self, f) => mapWithIndex(self, (a) => f(a)))

@@ -173,7 +173,7 @@

export const mapWithIndex: {
<A, K, B>(f: (a: A, k: K) => B): (self: SortedMap<K, A>) => SortedMap<K, B>
<K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B): SortedMap<K, B>
<A, K, B>(f: (a: A, k: K) => B): (self: SortedMap<K, A>) => SortedMap<K, B>
} = Dual.dual<
<K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B) => SortedMap<K, B>,
<A, K, B>(f: (a: A, k: K) => B) => (self: SortedMap<K, A>) => SortedMap<K, B>
<A, K, B>(f: (a: A, k: K) => B) => (self: SortedMap<K, A>) => SortedMap<K, B>,
<K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B) => SortedMap<K, B>
>(2, <K, A, B>(self: SortedMap<K, A>, f: (a: A, k: K) => B) =>

@@ -197,7 +197,7 @@ reduceWithIndex(

export const reduce: {
<V, B>(zero: B, f: (accumulator: B, value: V) => B): <K>(self: SortedMap<K, V>) => B
<K, V, B>(self: SortedMap<K, V>, zero: B, f: (accumulator: B, value: V) => B): B
<V, B>(zero: B, f: (accumulator: B, value: V) => B): <K>(self: SortedMap<K, V>) => B
} = Dual.dual<
<K, V, B>(self: SortedMap<K, V>, zero: B, f: (accumulator: B, value: V) => B) => B,
<V, B>(zero: B, f: (accumulator: B, value: V) => B) => <K>(self: SortedMap<K, V>) => B
<V, B>(zero: B, f: (accumulator: B, value: V) => B) => <K>(self: SortedMap<K, V>) => B,
<K, V, B>(self: SortedMap<K, V>, zero: B, f: (accumulator: B, value: V) => B) => B
>(3, (self, zero, f) => RBT.reduce(self.tree, zero, f))

@@ -210,7 +210,7 @@

export const reduceWithIndex: {
<B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B): (self: SortedMap<K, A>) => B
<K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B): B
<B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B): (self: SortedMap<K, A>) => B
} = Dual.dual<
<K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B) => B,
<B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B) => (self: SortedMap<K, A>) => B
<B, A, K>(zero: B, f: (acc: B, value: A, key: K) => B) => (self: SortedMap<K, A>) => B,
<K, A, B>(self: SortedMap<K, A>, zero: B, f: (acc: B, value: A, key: K) => B) => B
>(3, (self, zero, f) => RBT.reduceWithIndex(self.tree, zero, f))

@@ -223,7 +223,7 @@

export const remove: {
<K>(key: K): <V>(self: SortedMap<K, V>) => SortedMap<K, V>
<K, V>(self: SortedMap<K, V>, key: K): SortedMap<K, V>
<K>(key: K): <V>(self: SortedMap<K, V>) => SortedMap<K, V>
} = Dual.dual<
<K, V>(self: SortedMap<K, V>, key: K) => SortedMap<K, V>,
<K>(key: K) => <V>(self: SortedMap<K, V>) => SortedMap<K, V>
<K>(key: K) => <V>(self: SortedMap<K, V>) => SortedMap<K, V>,
<K, V>(self: SortedMap<K, V>, key: K) => SortedMap<K, V>
>(2, (self, key) => new SortedMapImpl(RBT.removeFirst(self.tree, key)))

@@ -236,7 +236,7 @@

export const set: {
<K, V>(key: K, value: V): (self: SortedMap<K, V>) => SortedMap<K, V>
<K, V>(self: SortedMap<K, V>, key: K, value: V): SortedMap<K, V>
<K, V>(key: K, value: V): (self: SortedMap<K, V>) => SortedMap<K, V>
} = Dual.dual<
<K, V>(self: SortedMap<K, V>, key: K, value: V) => SortedMap<K, V>,
<K, V>(key: K, value: V) => (self: SortedMap<K, V>) => SortedMap<K, V>
<K, V>(key: K, value: V) => (self: SortedMap<K, V>) => SortedMap<K, V>,
<K, V>(self: SortedMap<K, V>, key: K, value: V) => SortedMap<K, V>
>(3, (self, key, value) =>

@@ -243,0 +243,0 @@ RBT.has(self.tree, key)

113

src/SortedSet.ts
/**
* @since 1.0.0
*/
import * as Dual from "@effect/data/Dual"
import * as Equal from "@effect/data/Equal"
import * as Hash from "@effect/data/Hash"
import * as RBT from "@effect/data/RedBlackTree"
import * as Dual from "@fp-ts/core/Function"
import { pipe } from "@fp-ts/core/Function"

@@ -100,7 +100,7 @@ import type { Predicate, Refinement } from "@fp-ts/core/Predicate"

export const add: {
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>
<A>(self: SortedSet<A>, value: A): SortedSet<A>
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
<A>(self: SortedSet<A>, value: A) => SortedSet<A>,
<A>(value: A) => (self: SortedSet<A>) => SortedSet<A>
<A>(value: A) => (self: SortedSet<A>) => SortedSet<A>,
<A>(self: SortedSet<A>, value: A) => SortedSet<A>
>(2, (self, value) =>

@@ -116,7 +116,7 @@ RBT.has(self.keyTree, value)

export const difference: {
<A, B extends A>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>
<A, B extends A>(self: SortedSet<A>, that: Iterable<B>): SortedSet<A>
<A, B extends A>(that: Iterable<B>): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
<A, B extends A>(self: SortedSet<A>, that: Iterable<B>) => SortedSet<A>,
<A, B extends A>(that: Iterable<B>) => (self: SortedSet<A>) => SortedSet<A>
<A, B extends A>(that: Iterable<B>) => (self: SortedSet<A>) => SortedSet<A>,
<A, B extends A>(self: SortedSet<A>, that: Iterable<B>) => SortedSet<A>
>(2, <A, B extends A>(self: SortedSet<A>, that: Iterable<B>) => {

@@ -135,7 +135,7 @@ let out = self

export const every: {
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
<A>(self: SortedSet<A>, predicate: Predicate<A>): boolean
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
} = Dual.dual<
<A>(self: SortedSet<A>, predicate: Predicate<A>) => boolean,
<A>(predicate: Predicate<A>) => (self: SortedSet<A>) => boolean
<A>(predicate: Predicate<A>) => (self: SortedSet<A>) => boolean,
<A>(self: SortedSet<A>, predicate: Predicate<A>) => boolean
>(2, (self, predicate) => {

@@ -155,14 +155,14 @@ for (const value of self) {

export const filter: {
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
<A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>
<A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
{
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
},
{
<A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): SortedSet<B>
<A>(self: SortedSet<A>, predicate: Predicate<A>): SortedSet<A>
},
{
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => SortedSet<B>
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => SortedSet<A>
}

@@ -185,7 +185,7 @@ >(2, <A>(self: SortedSet<A>, predicate: Predicate<A>) => {

export const flatMap: {
<B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>
<A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>): SortedSet<B>
<B, A>(O: Order<B>, f: (a: A) => Iterable<B>): (self: SortedSet<A>) => SortedSet<B>
} = Dual.dual<
<A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>) => SortedSet<B>,
<B, A>(O: Order<B>, f: (a: A) => Iterable<B>) => (self: SortedSet<A>) => SortedSet<B>
<B, A>(O: Order<B>, f: (a: A) => Iterable<B>) => (self: SortedSet<A>) => SortedSet<B>,
<A, B>(self: SortedSet<A>, O: Order<B>, f: (a: A) => Iterable<B>) => SortedSet<B>
>(3, (self, O, f) => {

@@ -206,7 +206,7 @@ let out = empty(O)

export const forEach: {
<A>(f: (a: A) => void): (self: SortedSet<A>) => void
<A>(self: SortedSet<A>, f: (a: A) => void): void
<A>(f: (a: A) => void): (self: SortedSet<A>) => void
} = Dual.dual<
<A>(self: SortedSet<A>, f: (a: A) => void) => void,
<A>(f: (a: A) => void) => (self: SortedSet<A>) => void
<A>(f: (a: A) => void) => (self: SortedSet<A>) => void,
<A>(self: SortedSet<A>, f: (a: A) => void) => void
>(2, (self, f) => RBT.forEach(self.keyTree, f))

@@ -219,7 +219,7 @@

export const has: {
<A>(value: A): (self: SortedSet<A>) => boolean
<A>(self: SortedSet<A>, value: A): boolean
<A>(value: A): (self: SortedSet<A>) => boolean
} = Dual.dual<
<A>(self: SortedSet<A>, value: A) => boolean,
<A>(value: A) => (self: SortedSet<A>) => boolean
<A>(value: A) => (self: SortedSet<A>) => boolean,
<A>(self: SortedSet<A>, value: A) => boolean
>(2, (self, value) => RBT.has(self.keyTree, value))

@@ -232,7 +232,7 @@

export const intersection: {
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>
<A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
<A>(self: SortedSet<A>, that: Iterable<A>) => SortedSet<A>,
<A>(that: Iterable<A>) => (self: SortedSet<A>) => SortedSet<A>
<A>(that: Iterable<A>) => (self: SortedSet<A>) => SortedSet<A>,
<A>(self: SortedSet<A>, that: Iterable<A>) => SortedSet<A>
>(2, (self, that) => {

@@ -254,7 +254,7 @@ const ord = RBT.getOrder(self.keyTree)

export const isSubset: {
<A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean
<A>(self: SortedSet<A>, that: SortedSet<A>): boolean
<A>(that: SortedSet<A>): (self: SortedSet<A>) => boolean
} = Dual.dual<
<A>(self: SortedSet<A>, that: SortedSet<A>) => boolean,
<A>(that: SortedSet<A>) => (self: SortedSet<A>) => boolean
<A>(that: SortedSet<A>) => (self: SortedSet<A>) => boolean,
<A>(self: SortedSet<A>, that: SortedSet<A>) => boolean
>(2, (self, that) => every(self, (a) => has(that, a)))

@@ -267,7 +267,7 @@

export const map: {
<B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>
<B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B): SortedSet<B>
<B, A>(O: Order<B>, f: (a: A) => B): (self: SortedSet<A>) => SortedSet<B>
} = Dual.dual<
<B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B) => SortedSet<B>,
<B, A>(O: Order<B>, f: (a: A) => B) => (self: SortedSet<A>) => SortedSet<B>
<B, A>(O: Order<B>, f: (a: A) => B) => (self: SortedSet<A>) => SortedSet<B>,
<B, A>(self: SortedSet<A>, O: Order<B>, f: (a: A) => B) => SortedSet<B>
>(3, (self, O, f) => {

@@ -289,24 +289,19 @@ let out = empty(O)

export const partition: {
<A, B extends A>(
self: SortedSet<A>,
refinement: Refinement<A, B>
): readonly [SortedSet<A>, SortedSet<B>]
<A, B extends A>(refinement: Refinement<A, B>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<B>]
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<A>]
<A, B extends A>(self: SortedSet<A>, refinement: Refinement<A, B>): readonly [SortedSet<A>, SortedSet<B>]
<A>(self: SortedSet<A>, predicate: Predicate<A>): readonly [SortedSet<A>, SortedSet<A>]
<A, B extends A>(
refinement: Refinement<A, B>
): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<B>]
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<A>]
} = Dual.dual<
{
<A, B extends A>(
self: SortedSet<A>,
refinement: Refinement<A, B>
): readonly [SortedSet<A>, SortedSet<B>]
<A>(self: SortedSet<A>, predicate: Predicate<A>): readonly [SortedSet<A>, SortedSet<A>]
): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<B>]
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<A>]
},
{
<A, B extends A>(
self: SortedSet<A>,
refinement: Refinement<A, B>
): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<B>]
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => readonly [SortedSet<A>, SortedSet<A>]
): readonly [SortedSet<A>, SortedSet<B>]
<A>(self: SortedSet<A>, predicate: Predicate<A>): readonly [SortedSet<A>, SortedSet<A>]
}

@@ -332,7 +327,7 @@ >(2, <A>(self: SortedSet<A>, predicate: Predicate<A>) => {

export const remove: {
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>
<A>(self: SortedSet<A>, value: A): SortedSet<A>
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
<A>(self: SortedSet<A>, value: A) => SortedSet<A>,
<A>(value: A) => (self: SortedSet<A>) => SortedSet<A>
<A>(value: A) => (self: SortedSet<A>) => SortedSet<A>,
<A>(self: SortedSet<A>, value: A) => SortedSet<A>
>(2, (self, value) => new SortedSetImpl(RBT.removeFirst(self.keyTree, value)))

@@ -351,7 +346,7 @@

export const some: {
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
<A>(self: SortedSet<A>, predicate: Predicate<A>): boolean
<A>(predicate: Predicate<A>): (self: SortedSet<A>) => boolean
} = Dual.dual<
<A>(self: SortedSet<A>, predicate: Predicate<A>) => boolean,
<A>(predicate: Predicate<A>) => (self: SortedSet<A>) => boolean
<A>(predicate: Predicate<A>) => (self: SortedSet<A>) => boolean,
<A>(self: SortedSet<A>, predicate: Predicate<A>) => boolean
>(2, (self, predicate) => {

@@ -371,7 +366,7 @@ for (const value of self) {

export const toggle: {
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>
<A>(self: SortedSet<A>, value: A): SortedSet<A>
<A>(value: A): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
<A>(self: SortedSet<A>, value: A) => SortedSet<A>,
<A>(value: A) => (self: SortedSet<A>) => SortedSet<A>
<A>(value: A) => (self: SortedSet<A>) => SortedSet<A>,
<A>(self: SortedSet<A>, value: A) => SortedSet<A>
>(2, (self, value) => has(self, value) ? remove(self, value) : add(self, value))

@@ -384,7 +379,7 @@

export const union: {
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>
<A>(self: SortedSet<A>, that: Iterable<A>): SortedSet<A>
<A>(that: Iterable<A>): (self: SortedSet<A>) => SortedSet<A>
} = Dual.dual<
<A>(self: SortedSet<A>, that: Iterable<A>) => SortedSet<A>,
<A>(that: Iterable<A>) => (self: SortedSet<A>) => SortedSet<A>
<A>(that: Iterable<A>) => (self: SortedSet<A>) => SortedSet<A>,
<A>(self: SortedSet<A>, that: Iterable<A>) => SortedSet<A>
>(2, <A>(self: SortedSet<A>, that: Iterable<A>) => {

@@ -391,0 +386,0 @@ const ord = RBT.getOrder(self.keyTree)

Dual.d.ts
Dual.d.ts.map
Dual.js
Dual.js.map
mjs/Dual.mjs
mjs/Dual.mjs.map
src/Dual.ts
Brand.d.ts.map

Sorry, the diff of this file is not supported yet

Brand.js.map

Sorry, the diff of this file is not supported yet

Chunk.d.ts.map

Sorry, the diff of this file is not supported yet

Chunk.js.map

Sorry, the diff of this file is not supported yet

Context.d.ts.map

Sorry, the diff of this file is not supported yet

Context.js.map

Sorry, the diff of this file is not supported yet

Differ.d.ts.map

Sorry, the diff of this file is not supported yet

Differ.js.map

Sorry, the diff of this file is not supported yet

Differ/ChunkPatch.d.ts.map

Sorry, the diff of this file is not supported yet

Differ/ChunkPatch.js.map

Sorry, the diff of this file is not supported yet

Differ/ContextPatch.d.ts.map

Sorry, the diff of this file is not supported yet

Differ/ContextPatch.js.map

Sorry, the diff of this file is not supported yet

Differ/HashMapPatch.d.ts.map

Sorry, the diff of this file is not supported yet

Differ/HashMapPatch.js.map

Sorry, the diff of this file is not supported yet

Differ/HashSetPatch.d.ts.map

Sorry, the diff of this file is not supported yet

Differ/OrPatch.d.ts.map

Sorry, the diff of this file is not supported yet

Differ/OrPatch.js.map

Sorry, the diff of this file is not supported yet

Duration.d.ts.map

Sorry, the diff of this file is not supported yet

Duration.js.map

Sorry, the diff of this file is not supported yet

HashMap.d.ts.map

Sorry, the diff of this file is not supported yet

HashSet.d.ts.map

Sorry, the diff of this file is not supported yet

index.d.ts.map

Sorry, the diff of this file is not supported yet

index.js.map

Sorry, the diff of this file is not supported yet

internal/Differ.js.map

Sorry, the diff of this file is not supported yet

internal/Differ/ChunkPatch.js.map

Sorry, the diff of this file is not supported yet

internal/Differ/ContextPatch.js.map

Sorry, the diff of this file is not supported yet

internal/Differ/HashMapPatch.js.map

Sorry, the diff of this file is not supported yet

internal/Differ/HashSetPatch.js.map

Sorry, the diff of this file is not supported yet

internal/Differ/OrPatch.js.map

Sorry, the diff of this file is not supported yet

internal/HashMap.d.ts.map

Sorry, the diff of this file is not supported yet

internal/HashMap.js.map

Sorry, the diff of this file is not supported yet

internal/HashSet.js.map

Sorry, the diff of this file is not supported yet

internal/RedBlackTree.d.ts.map

Sorry, the diff of this file is not supported yet

internal/RedBlackTree.js.map

Sorry, the diff of this file is not supported yet

List.d.ts.map

Sorry, the diff of this file is not supported yet

List.js.map

Sorry, the diff of this file is not supported yet

mjs/Brand.mjs

Sorry, the diff of this file is not supported yet

mjs/Brand.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Chunk.mjs

Sorry, the diff of this file is not supported yet

mjs/Chunk.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Context.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Differ.mjs

Sorry, the diff of this file is not supported yet

mjs/Differ.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Differ/ChunkPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Differ/ContextPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Differ/HashMapPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Differ/OrPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/Duration.mjs

Sorry, the diff of this file is not supported yet

mjs/Duration.mjs.map

Sorry, the diff of this file is not supported yet

mjs/index.mjs

Sorry, the diff of this file is not supported yet

mjs/index.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Context.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Context.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Differ.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Differ.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/ChunkPatch.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/ChunkPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/ContextPatch.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/ContextPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/HashMapPatch.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/HashMapPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/HashSetPatch.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/HashSetPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/OrPatch.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/Differ/OrPatch.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/HashMap.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/HashMap.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/HashSet.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/HashSet.mjs.map

Sorry, the diff of this file is not supported yet

mjs/internal/RedBlackTree.mjs

Sorry, the diff of this file is not supported yet

mjs/internal/RedBlackTree.mjs.map

Sorry, the diff of this file is not supported yet

mjs/List.mjs

Sorry, the diff of this file is not supported yet

mjs/List.mjs.map

Sorry, the diff of this file is not supported yet

mjs/MutableHashMap.mjs

Sorry, the diff of this file is not supported yet

mjs/MutableHashMap.mjs.map

Sorry, the diff of this file is not supported yet

mjs/MutableHashSet.mjs

Sorry, the diff of this file is not supported yet

mjs/MutableHashSet.mjs.map

Sorry, the diff of this file is not supported yet

mjs/MutableList.mjs

Sorry, the diff of this file is not supported yet

mjs/MutableList.mjs.map

Sorry, the diff of this file is not supported yet

mjs/MutableQueue.mjs

Sorry, the diff of this file is not supported yet

mjs/MutableQueue.mjs.map

Sorry, the diff of this file is not supported yet

mjs/MutableRef.mjs

Sorry, the diff of this file is not supported yet

mjs/MutableRef.mjs.map

Sorry, the diff of this file is not supported yet

mjs/RedBlackTree.mjs.map

Sorry, the diff of this file is not supported yet

mjs/SortedMap.mjs

Sorry, the diff of this file is not supported yet

mjs/SortedMap.mjs.map

Sorry, the diff of this file is not supported yet

mjs/SortedSet.mjs

Sorry, the diff of this file is not supported yet

mjs/SortedSet.mjs.map

Sorry, the diff of this file is not supported yet

MutableHashMap.d.ts.map

Sorry, the diff of this file is not supported yet

MutableHashMap.js.map

Sorry, the diff of this file is not supported yet

MutableHashSet.d.ts.map

Sorry, the diff of this file is not supported yet

MutableHashSet.js.map

Sorry, the diff of this file is not supported yet

MutableList.d.ts.map

Sorry, the diff of this file is not supported yet

MutableList.js.map

Sorry, the diff of this file is not supported yet

MutableQueue.d.ts.map

Sorry, the diff of this file is not supported yet

MutableQueue.js.map

Sorry, the diff of this file is not supported yet

MutableRef.d.ts.map

Sorry, the diff of this file is not supported yet

MutableRef.js.map

Sorry, the diff of this file is not supported yet

RedBlackTree.d.ts.map

Sorry, the diff of this file is not supported yet

RedBlackTree.js.map

Sorry, the diff of this file is not supported yet

SortedMap.d.ts.map

Sorry, the diff of this file is not supported yet

SortedSet.d.ts.map

Sorry, the diff of this file is not supported yet

SortedSet.js.map

Sorry, the diff of this file is not supported yet

SocketSocket SOC 2 Logo

Product

  • Package Alerts
  • Integrations
  • Docs
  • Pricing
  • FAQ
  • Roadmap
  • Changelog

About

Packages

npm

Go

Maven

PyPI

Rubygems

Stay in touch

Get open source security insights delivered straight into your inbox.

  • Terms
  • Privacy
  • Security

Made with ⚡️ by Socket Inc