@longlast/equals 0.2.1 → 0.4.0

package/dist/curry.d.ts

@@ -0,0 +1,7 @@
+type Func2<A, B, Out> = (a: A, b: B) => Out;
+export interface Curried2<A, B, Out> {
+    (a: A, b: B): Out;
+    (a: A): (b: B) => Out;
+}
+export declare function curry<A, B, Out>(f: Func2<A, B, Out>): Curried2<A, B, Out>;
+export {};

package/dist/curry.js

@@ -0,0 +1,12 @@
+export function curry(f) {
+    return function (a, b) {
+        if (arguments.length === f.length) {
+            return f(a, b);
+        }
+        else {
+            return function (b) {
+                return f(a, b);
+            };
+        }
+    };
+}

package/dist/index.d.ts

@@ -1,27 +1,32 @@
 /**
  * @module equals
  */
+import { type Curried2 } from "./curry.ts";
 /**
+ * @function
  * Deeply compares two values, returning true if they're equal and false
  * otherwise. The following criteria are used to determine equality:
  *
  *   - All values are always equal to themselves.
+ *   - Primitives `a` and `b` are equal iff `Object.is(a, b)`. This is similar
+ *     to `===` comparison, but treats `NaN` as equal to `NaN` and `0` as
+ *     different from `-0`.
+ *   - Dates are equal iff they have the same millisecond-precision timestamp.
+ *   - RegExps are equal iff they have the same pattern and flags.
+ *   - Errors are equal iff they have the same class and message.
  *   - Arrays are equal iff they have the same length and their corresponding
  *     elements are equal (according to `equals`).
- *   - Dates are equal iff they serialize to the same ISO string.
  *   - Sets are equal iff they contain the same elements. Note that set
  *     elements are _not_ deeply compared.
- *   - Errors are equal iff they have the same class and message.
  *   - Other objects are equal iff they have the same prototype (e.g. the same
  *     class) and the same set of enumerable string-keyed properties, and the
  *     values of their corresponding properties are equal (according to
  *     `equals`).
- *   - Primitives `a` and `b` are equal iff `Object.is(a, b)`. This is similar
- *     to `===` comparison, but treats `NaN` as equal to `NaN` and `0` as
- *     different from `-0`.
  *
  * `equals()` can throw a `RangeError` if one of its arguments contains a
  * reference cycle. Avoid passing mutable objects to `equals()` unless you know
  * that they do not contain cycles.
+ *
+ * `equals()` is curried.
  */
-export declare function equals(a: unknown, b: unknown): boolean;
+export declare const equals: Curried2<unknown, unknown, boolean>;

package/dist/index.js

@@ -1,46 +1,55 @@
 /**
  * @module equals
  */
+import { curry } from "./curry.js";
 /**
+ * @function
  * Deeply compares two values, returning true if they're equal and false
  * otherwise. The following criteria are used to determine equality:
  *
  *   - All values are always equal to themselves.
+ *   - Primitives `a` and `b` are equal iff `Object.is(a, b)`. This is similar
+ *     to `===` comparison, but treats `NaN` as equal to `NaN` and `0` as
+ *     different from `-0`.
+ *   - Dates are equal iff they have the same millisecond-precision timestamp.
+ *   - RegExps are equal iff they have the same pattern and flags.
+ *   - Errors are equal iff they have the same class and message.
  *   - Arrays are equal iff they have the same length and their corresponding
  *     elements are equal (according to `equals`).
- *   - Dates are equal iff they serialize to the same ISO string.
  *   - Sets are equal iff they contain the same elements. Note that set
  *     elements are _not_ deeply compared.
- *   - Errors are equal iff they have the same class and message.
  *   - Other objects are equal iff they have the same prototype (e.g. the same
  *     class) and the same set of enumerable string-keyed properties, and the
  *     values of their corresponding properties are equal (according to
  *     `equals`).
- *   - Primitives `a` and `b` are equal iff `Object.is(a, b)`. This is similar
- *     to `===` comparison, but treats `NaN` as equal to `NaN` and `0` as
- *     different from `-0`.
  *
  * `equals()` can throw a `RangeError` if one of its arguments contains a
  * reference cycle. Avoid passing mutable objects to `equals()` unless you know
  * that they do not contain cycles.
+ *
+ * `equals()` is curried.
  */
-export function equals(a, b) {
+export const equals = curry(_equals);
+function _equals(a, b) {
     if (Object.is(a, b)) {
         return true;
     }
-    if (Array.isArray(a) && Array.isArray(b)) {
-        return a.length === b.length && a.every((_, i) => equals(a[i], b[i]));
-    }
     if (a instanceof Date && b instanceof Date) {
         return Object.is(+a, +b);
     }
-    if (a instanceof Set && b instanceof Set) {
-        return equalSets(a, b);
+    if (a instanceof RegExp && b instanceof RegExp) {
+        return String(a) === String(b);
     }
     if (a instanceof Error && b instanceof Error) {
         return (a.message === b.message &&
             Object.getPrototypeOf(a) === Object.getPrototypeOf(b));
     }
+    if (a instanceof Set && b instanceof Set) {
+        return equalSets(a, b);
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.length === b.length && a.every((_, i) => equals(a[i], b[i]));
+    }
     if (isObject(a) && isObject(b)) {
         const aKeys = Object.keys(a);
         const bKeys = Object.keys(b);
@@ -51,7 +60,7 @@ export function equals(a, b) {
     return false;
 }
 function equalSets(a, b) {
-    return a.size === b.size && [...a.values()].every((v) => b.has(v));
+    return a.size === b.size && [...a].every((v) => b.has(v));
 }
 function isObject(x) {
     return !!x && typeof x === "object";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longlast/equals",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "type": "module",
   "files": [
     "dist"