@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 @@ /**

No alert changes

Improved metrics

Total package byte prevSize

2935498

0.01%

No dependency changes