@effect/data - npm Package Compare versions

Comparing version 0.16.2 to 0.16.3

Equivalence.d.ts

		@@ -87,4 +87,4 @@ import type { TypeLambda } from "@effect/data/HKT";
		export declare const product: {
		<B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<[A, B]>;
		<A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<[A, B]>;
		<B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<readonly [A, B]>;
		<A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]>;
		};
		@@ -95,3 +95,3 @@ /**
		*/
		export declare const all: <A>(collection: Iterable<Equivalence<A>>) => Equivalence<A[]>;
		export declare const all: <A>(collection: Iterable<Equivalence<A>>) => Equivalence<readonly A[]>;
		/**
		@@ -101,3 +101,3 @@ * @category combining
		*/
		export declare const productMany: <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>) => Equivalence<[A, ...A[]]>;
		export declare const productMany: <A>(self: Equivalence<A>, collection: Iterable<Equivalence<A>>) => Equivalence<readonly [A, ...A[]]>;
		/**
		@@ -104,0 +104,0 @@ * Similar to `Promise.all` but operates on `Equivalence`s.

Order.d.ts

		@@ -83,4 +83,4 @@ import type { TypeLambda } from "@effect/data/HKT";
		export declare const product: {
		<B>(that: Order<B>): <A>(self: Order<A>) => Order<[A, B]>;
		<A, B>(self: Order<A>, that: Order<B>): Order<[A, B]>;
		<B>(that: Order<B>): <A>(self: Order<A>) => Order<readonly [A, B]>;
		<A, B>(self: Order<A>, that: Order<B>): Order<readonly [A, B]>;
		};
		@@ -91,3 +91,3 @@ /**
		*/
		export declare const all: <A>(collection: Iterable<Order<A>>) => Order<A[]>;
		export declare const all: <A>(collection: Iterable<Order<A>>) => Order<readonly A[]>;
		/**
		@@ -98,4 +98,4 @@ * @category combining
		export declare const productMany: {
		<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<[A, ...Array<A>]>;
		<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<[A, ...Array<A>]>;
		<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<readonly [A, ...Array<A>]>;
		<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<readonly [A, ...Array<A>]>;
		};
		@@ -117,3 +117,3 @@ /**
		*/
		export declare const tuple: <T extends readonly Order<any>[]>(...elements: T) => Order<{ [I in keyof T]: [T[I]] extends [Order<infer A>] ? A : never; }>;
		export declare const tuple: <T extends readonly Order<any>[]>(...elements: T) => Order<Readonly<{ [I in keyof T]: [T[I]] extends [Order<infer A>] ? A : never; }>>;
		/**
		@@ -120,0 +120,0 @@ * This function creates and returns a new `Order` for an array of values based on a given `Order` for the elements of the array.

package.json

		{
		"name": "@effect/data",
		"version": "0.16.2",
		"version": "0.16.3",
		"license": "MIT",
		@@ -5,0 +5,0 @@ "repository": {

src/Equivalence.ts

		@@ -129,7 +129,7 @@ /**
		export const product: {
		<B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<[A, B]>
		<A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<[A, B]>
		<B>(that: Equivalence<B>): <A>(self: Equivalence<A>) => Equivalence<readonly [A, B]>
		<A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]>
		} = dual(
		2,
		<A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<[A, B]> =>
		<A, B>(self: Equivalence<A>, that: Equivalence<B>): Equivalence<readonly [A, B]> =>
		make(([xa, xb], [ya, yb]) => self(xa, ya) && that(xb, yb))
		@@ -142,3 +142,3 @@ )
		*/
		export const all = <A>(collection: Iterable<Equivalence<A>>): Equivalence<Array<A>> => {
		export const all = <A>(collection: Iterable<Equivalence<A>>): Equivalence<ReadonlyArray<A>> => {
		return make((x, y) => {
		@@ -168,3 +168,3 @@ const len = Math.min(x.length, y.length)
		collection: Iterable<Equivalence<A>>
		): Equivalence<[A, ...Array<A>]> => {
		): Equivalence<readonly [A, ...Array<A>]> => {
		const equivalence = all(collection)
		@@ -171,0 +171,0 @@ return make((x, y) => !self(x[0], y[0]) ? false : equivalence(x.slice(1), y.slice(1)))

src/Order.ts

		@@ -126,5 +126,5 @@ /**
		export const product: {
		<B>(that: Order<B>): <A>(self: Order<A>) => Order<[A, B]>
		<A, B>(self: Order<A>, that: Order<B>): Order<[A, B]>
		} = dual(2, <A, B>(self: Order<A>, that: Order<B>): Order<[A, B]> =>
		<B>(that: Order<B>): <A>(self: Order<A>) => Order<readonly [A, B]>
		<A, B>(self: Order<A>, that: Order<B>): Order<readonly [A, B]>
		} = dual(2, <A, B>(self: Order<A>, that: Order<B>): Order<readonly [A, B]> =>
		make(([xa, xb], [ya, yb]) => {
		@@ -139,3 +139,3 @@ const o = self(xa, ya)
		*/
		export const all = <A>(collection: Iterable<Order<A>>): Order<Array<A>> => {
		export const all = <A>(collection: Iterable<Order<A>>): Order<ReadonlyArray<A>> => {
		return make((x, y) => {
		@@ -163,5 +163,5 @@ const len = Math.min(x.length, y.length)
		export const productMany: {
		<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<[A, ...Array<A>]>
		<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<[A, ...Array<A>]>
		} = dual(2, <A>(self: Order<A>, collection: Iterable<Order<A>>): Order<[A, ...Array<A>]> => {
		<A>(collection: Iterable<Order<A>>): (self: Order<A>) => Order<readonly [A, ...Array<A>]>
		<A>(self: Order<A>, collection: Iterable<Order<A>>): Order<readonly [A, ...Array<A>]>
		} = dual(2, <A>(self: Order<A>, collection: Iterable<Order<A>>): Order<readonly [A, ...Array<A>]> => {
		const O = all(collection)
		@@ -191,3 +191,3 @@ return make((x, y) => {
		...elements: T
		): Order<{ [I in keyof T]: [T[I]] extends [Order<infer A>] ? A : never }> => all(elements) as any
		): Order<Readonly<{ [I in keyof T]: [T[I]] extends [Order<infer A>] ? A : never }>> => all(elements) as any

		@@ -194,0 +194,0 @@ /**

Equivalence.d.ts.map