🎨 improve @coven/compare.

Author: loucyx

@coven/compare/CreateDifference.ts

@@ -8,7 +8,7 @@ import type { DifferencePath } from "./DifferencePath.ts";
  * ```typescript
  * const createDifference = {
  * 	kind: "CREATE",
- * 	path: ["foo", "bar"],
+ * 	path: ["property", "path"],
  * 	right: "new value",
  * } as const satisfies CreateDifference<string>;
  * ```
@@ -19,6 +19,7 @@ export type CreateDifference<Right = unknown> = {
 	 * Creation kind.
 	 */
 	readonly kind: typeof CREATE;
+
 	/**
 	 * New value.
 	 */

@coven/compare/CurriedComparison.ts

@@ -1,3 +1,20 @@
 import type { Difference } from "./Difference.ts";
 
+/**
+ * Curried function returned by `compare` function when it already took a `left`
+ * (original) value.
+ *
+ * @example
+ * ```typescript
+ * const compare = <Left>(left: string): CurriedComparison<string> =>
+ * 	function* (right) {
+ * 		yield {
+ * 			// Difference object
+ * 		}
+ * 	}
+ * ```
+ *
+ * @template Right Right value to compare
+ * @returns Generator that yields `Difference` objects.
+ */
 export type CurriedComparison<Right> = (right: Right) => Generator<Difference>;

@coven/compare/DeleteDifference.ts

@@ -12,15 +12,16 @@ import type { DifferencePath } from "./DifferencePath.ts";
  * 	path: ["foo", "bar"],
  * } as const satisfies DeleteDifference<string>;
  * ```
- * @template Left Type of the removed value.
+ * @template Left Type of the removed/original value.
  */
 export type DeleteDifference<Left = unknown> = {
 	/**
 	 * Deletion kind.
 	 */
 	readonly kind: typeof DELETE;
+
 	/**
-	 * Original value.
+	 * Removed/original value.
 	 */
 	readonly left: Left;
 } & DifferencePath;

@coven/compare/UpdateDifference.ts

@@ -13,8 +13,8 @@ import type { DifferencePath } from "./DifferencePath.ts";
  * 	right: "new value",
  * } as const satisfies UpdateDifference<string, string>;
  * ```
- * @template Left Type of the new value.
- * @template Right Type of the original value.
+ * @template Left Type of the original value.
+ * @template Right Type of the new value.
  */
 export type UpdateDifference<Left = unknown, Right = unknown> = {
 	/**

@coven/compare/compare.ts

@@ -1,10 +1,14 @@
+import { is, isObject } from "@coven/predicates";
 import type { Just } from "@coven/types";
+import { always } from "@coven/utils";
 import type { CurriedComparison } from "./CurriedComparison.ts";
 import type { Difference } from "./Difference.ts";
 import { compareObjects } from "./compareObjects.ts";
-import { isObject } from "./isObject.ts";
 import { valueToDifference } from "./valueToDifference.ts";
 
+// deno-lint-ignore no-boolean-literal-for-arguments
+const alwaysFalse = always(false);
+
 /**
  * Function to compare a `left` and a `right` value, by doing a deep comparison
  * and yielding the differences found with a descriptive object.
@@ -28,6 +32,8 @@ export const compare = (left: unknown): CurriedComparison<unknown> => {
 	const valuesToDifferenceLeft = valueToDifference(left);
 	const leftIsObject = isObject(left);
 	const compareObjectsLeft = leftIsObject ? compareObjects(left) : undefined;
+	const isLeft = is(left);
+	const isLeftConstructor = leftIsObject ? is(left.constructor) : alwaysFalse;
 
 	return leftIsObject
 		/**
@@ -37,13 +43,12 @@ export const compare = (left: unknown): CurriedComparison<unknown> => {
 		 * @yields Differences.
 		 */
 		? function* (right): Generator<Difference> {
-			Object.is(left, right)
-				? undefined
-				: isObject(right) && left.constructor === right.constructor
-				? yield* (
-					compareObjectsLeft as Just<typeof compareObjectsLeft>
-				)(right)
-				: yield valuesToDifferenceLeft(right);
+			isLeft(right) ? undefined : yield* (
+				isObject(right) &&
+					isLeftConstructor((right as object).constructor)
+					? compareObjectsLeft as Just<typeof compareObjectsLeft>
+					: valuesToDifferenceLeft
+			)(right);
 		}
 		/**
 		 * Curried {@link compare} with `left` set in context.
@@ -52,8 +57,8 @@ export const compare = (left: unknown): CurriedComparison<unknown> => {
 		 * @yields Differences.
 		 */
 		: function* (right): Generator<Difference> {
-			Object.is(left, right) ? undefined : (
-				yield valuesToDifferenceLeft(right)
+			isLeft(right) ? undefined : (
+				yield* valuesToDifferenceLeft(right)
 			);
 		};
 };

@coven/compare/compareIterables.ts

@@ -1,3 +1,4 @@
+import { getIterator } from "@coven/iterables";
 import { compare } from "./compare.ts";
 import { DONE, MISSING, NEXT, VALUE } from "./constants.ts";
 import type { CurriedComparison } from "./CurriedComparison.ts";
@@ -20,15 +21,15 @@ import { pathPrepend } from "./pathPrepend.ts";
 export const compareIterables = <LeftItem>(
 	left: Iterable<LeftItem>,
 ): CurriedComparison<Iterable<LeftItem>> => {
-	const leftIterator = left[Symbol.iterator]();
+	const leftIterator = getIterator(left);
 
 	/**
 	 * Curried {@link compareIterables} with `left` set in context.
 	 * @param right Right/New iterable.
 	 * @returns Generator with differences.
 	 */
 	return function* (right): Generator<Difference> {
-		const rightIterator = right[Symbol.iterator]();
+		const rightIterator = getIterator(right);
 
 		for (
 			let index = 0,

@coven/compare/compareObjects.ts

@@ -34,7 +34,7 @@ export const compareObjects = (left: object): CurriedComparison<object> => {
 		 * @returns Generator with differences.
 		 */
 		? function* (right): Generator<Difference> {
-			yield* Symbol.iterator in right
+			yield* isIterable(right)
 				? (compareIterableLeft as Just<typeof compareIterableLeft>)(
 					right as Iterable<object>,
 				)

@coven/compare/deno.json

@@ -1,5 +1,5 @@
 {
 	"name": "@coven/compare",
-	"version": "0.0.8",
+	"version": "0.1.0",
 	"exports": "./mod.ts"
 }

@coven/compare/getKeys.ts

@@ -1,4 +1,4 @@
-import { isObject } from "./isObject.ts";
+import { isObject } from "@coven/predicates";
 
 /**
  * Recursively get all object keys going up the prototype chain.

@coven/compare/isObject.ts

@@ -20,7 +20,6 @@ export type { DeleteDifference } from "./DeleteDifference.ts";
 export type { Difference } from "./Difference.ts";
 export type { DifferencePath } from "./DifferencePath.ts";
 export { getKeys } from "./getKeys.ts";
-export { isObject } from "./isObject.ts";
 export { pathPrepend } from "./pathPrepend.ts";
 export type { UpdateDifference } from "./UpdateDifference.ts";
 export { valueToDifference } from "./valueToDifference.ts";

@coven/compare/mod.ts

@@ -1,7 +1,10 @@
 import { prepend } from "@coven/iterables";
+import { set } from "@coven/utils";
 import type { Difference } from "./Difference.ts";
 import { PATH } from "./constants.ts";
 
+const setPath = set(PATH);
+
 /**
  * Prepends the given property to the given {@link Difference}'s path.
  *
@@ -24,8 +27,5 @@ export const pathPrepend = <SourceDifference extends Difference>(
 	 * @yields Difference's path with prepended `prepend`.
 	 */
 	return ({ [PATH]: path, ...difference }) =>
-		({
-			...difference,
-			[PATH]: prependProperty(path ?? []),
-		}) as SourceDifference;
+		setPath(prependProperty(path ?? []))(difference) as SourceDifference;
 };

@coven/compare/pathPrepend.ts

@@ -1,3 +1,4 @@
+import type { CurriedComparison } from "./CurriedComparison.ts";
 import type { Difference } from "./Difference.ts";
 import {
 	CREATE,
@@ -25,32 +26,32 @@ import {
  * ```
  * @see {@link Difference}
  * @param left Left/Original value.
- * @returns Curried function with `left` in context.
+ * @returns Curried generator with `left` in context.
  */
 export const valueToDifference = (
 	left: unknown,
-): (right: unknown) => Difference =>
+): CurriedComparison<unknown> =>
 	left === MISSING
 		/**
 		 * Curried {@link valueToDifference} with `left` in context.
 		 * @param right Right/New value.
 		 * @returns Difference object.
 		 */
-		? (right: unknown) =>
-			({
-				...(right === MISSING ? undefined : (
-					{ [KIND]: CREATE, [RIGHT]: right }
-				)),
-			}) as Difference
+		? function* (right: unknown): Generator<Difference> {
+			right === MISSING
+				? undefined
+				: yield ({ [KIND]: CREATE, [RIGHT]: right });
+		}
 		/**
 		 * Curried {@link valueToDifference} with `left` in context.
 		 * @param right Right/New value.
 		 * @returns Difference object.
 		 */
-		: (right: unknown) =>
-			({
+		: function* (right: unknown): Generator<Difference> {
+			yield ({
 				[LEFT]: left,
 				...(right === MISSING
 					? { [KIND]: DELETE }
 					: { [KIND]: UPDATE, [RIGHT]: right }),
-			}) as Difference;
+			});
+		};

@coven/compare/valueToDifference.ts

@@ -18,7 +18,7 @@ Deno.test("Prepend key to existing path", () =>
 		{ kind: DELETE, left: "🧙🏻‍♀️", path: [13, 42] },
 	));
 
-Deno.test("Prepend key to missing path", () =>
+Deno.test("Prepend key to missing path yields prepended key", () =>
 	assertEquals(flatCompare(prepend13({ kind: DELETE, left: "🧙🏻‍♀️" })), {
 		kind: DELETE,
 		left: "🧙🏻‍♀️",

tests/@coven/compare/pathPrepend.test.ts

@@ -1,5 +1,5 @@
-import { type Difference, MISSING, valueToDifference } from "@coven/compare";
+import { MISSING, valueToDifference } from "@coven/compare";
 import { assertEquals } from "@std/assert";
 
 Deno.test("When both values are missing returns an empty difference", () =>
-	assertEquals(valueToDifference(MISSING)(MISSING), {} as Difference));
+	assertEquals([...valueToDifference(MISSING)(MISSING)], []));