@coven/memo refactor and introducing @coven/template

.github/workflows/publish.yml

@@ -39,7 +39,7 @@ jobs:
                   coverage.lcov
 
             - name: Publish Coverage
-              uses: codecov/codecov-action@v5
+              uses: codecov/codecov-action@v6
               with:
                   token: ${{ secrets.CODECOV_TOKEN }}
     publish:

@coven/compare/compareIterables.ts

@@ -1,3 +1,4 @@
+import { SIGIL } from "@coven/constants";
 import {
 	getIterator,
 	iteratorFunctionToIterableIterator,
@@ -6,7 +7,6 @@ import {
 import { compare } from "./compare.ts";
 import type { CurriedComparison } from "./CurriedComparison.ts";
 import type { Difference } from "./Difference.ts";
-import { MISSING_VALUE } from "./MISSING_VALUE.ts";
 import { pathPrepend } from "./pathPrepend.ts";
 
 /**
@@ -55,8 +55,8 @@ export const compareIterables =
 						rightIterator.next()
 			) {
 				yield* map(pathPrepend(index))(
-					compare(leftDone ? MISSING_VALUE : leftValue)(
-						rightDone ? MISSING_VALUE : rightValue,
+					compare(leftDone ? SIGIL : leftValue)(
+						rightDone ? SIGIL : rightValue,
 					),
 				);
 			}

@coven/compare/compareProperties.ts

@@ -1,3 +1,4 @@
+import { SIGIL } from "@coven/constants";
 import {
 	append,
 	EMPTY_ITERABLE_ITERATOR,
@@ -10,7 +11,6 @@ import { compare } from "./compare.ts";
 import type { CurriedComparison } from "./CurriedComparison.ts";
 import { differentiate } from "./differentiate.ts";
 import { getKeys } from "./getKeys.ts";
-import { MISSING_VALUE } from "./MISSING_VALUE.ts";
 import { pathPrepend } from "./pathPrepend.ts";
 
 /**
@@ -49,11 +49,11 @@ export const compareProperties = (left: object): CurriedComparison<unknown> => {
 						compare(
 							key in left ?
 								left[key as keyof typeof left]
-							:	MISSING_VALUE,
+							:	SIGIL,
 						)(
 							key in right ?
 								right[key as keyof typeof right]
-							:	MISSING_VALUE,
+							:	SIGIL,
 						),
 					),
 				)(unique(append(getKeys(right))(ownKeysLeft))),

@coven/compare/deno.json

@@ -2,5 +2,5 @@
 	"$schema": "https://raw.githubusercontent.com/denoland/deno/main/cli/schemas/config-file.v1.json",
 	"exports": "./mod.ts",
 	"name": "@coven/compare",
-	"version": "0.8.5"
+	"version": "0.9.0"
 }

@coven/compare/differentiate.ts

@@ -1,9 +1,8 @@
 import { EMPTY_ITERABLE_ITERATOR, toIterable } from "@coven/iterables";
-import { is } from "@coven/predicates";
+import { is, isSigil } from "@coven/predicates";
 import { CREATE_KIND } from "./CREATE_KIND.ts";
 import type { CurriedComparison } from "./CurriedComparison.ts";
 import { DELETE_KIND } from "./DELETE_KIND.ts";
-import { MISSING_VALUE } from "./MISSING_VALUE.ts";
 import { UPDATE_KIND } from "./UPDATE_KIND.ts";
 
 /**
@@ -17,15 +16,15 @@ import { UPDATE_KIND } from "./UPDATE_KIND.ts";
  *
  * @example Missing right value
  * ```typescript
- * import { MISSING_VALUE } from "@coven/compare";
+ * import { SIGIL } from "@coven/constants";
  *
- * differentiate("✨")(MISSING_VALUE); // Yields { kind: "DELETE", left: "✨", path: [] }
+ * differentiate("✨")(SIGIL); // Yields { kind: "DELETE", left: "✨", path: [] }
  * ```
  * @example Missing left value
  * ```typescript
- * import { MISSING_VALUE } from "@coven/compare";
+ * import { SIGIL } from "@coven/constants";
  *
- * differentiate(MISSING_VALUE)("🎃"); // Yields { kind: "CREATE", right: "🎃", path: [] }
+ * differentiate(SIGIL)("🎃"); // Yields { kind: "CREATE", right: "🎃", path: [] }
  * ```
  * @example Both values set
  * ```typescript
@@ -34,9 +33,9 @@ import { UPDATE_KIND } from "./UPDATE_KIND.ts";
  * ```
  * @example Both values missing
  * ```typescript
- * import { MISSING_VALUE } from "@coven/compare";
+ * import { SIGIL } from "@coven/constants";
  *
- * differentiate(MISSING_VALUE)(MISSING_VALUE); // Yields nothing
+ * differentiate(SIGIL)(SIGIL); // Yields nothing
  * ```
  * @param left Left/Original value.
  * @returns Curried generator with `left` in context.
@@ -54,8 +53,8 @@ export const differentiate = (left: unknown): CurriedComparison<unknown> => {
 		isLeft(right) ?
 			EMPTY_ITERABLE_ITERATOR
 		:	toIterable({
-				...(right === MISSING_VALUE ? { left, kind: DELETE_KIND }
-				: left === MISSING_VALUE ? { kind: CREATE_KIND, right }
+				...(isSigil(right) ? { left, kind: DELETE_KIND }
+				: isSigil(left) ? { kind: CREATE_KIND, right }
 				: { left, kind: UPDATE_KIND, right }),
 				path: EMPTY_ITERABLE_ITERATOR,
 			});

@coven/compare/mod.ts

@@ -14,7 +14,6 @@ export type { FlatDifference } from "./FlatDifference.ts";
 export type { FlatPath } from "./FlatPath.ts";
 export { flatPathMap } from "./flatPathMap.ts";
 export { getKeys } from "./getKeys.ts";
-export { MISSING_VALUE } from "./MISSING_VALUE.ts";
 export { pathPrepend } from "./pathPrepend.ts";
 export { setPath } from "./setPath.ts";
 export { UPDATE_KIND } from "./UPDATE_KIND.ts";

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

@@ -1,14 +1,12 @@
-import {
-	compare,
-	CREATE_KIND,
-	DELETE_KIND,
-	flat,
-	UPDATE_KIND,
-} from "@coven/compare";
 import { EMPTY_ARRAY, EMPTY_OBJECT } from "@coven/constants";
 import { EMPTY_ITERABLE_ITERATOR } from "@coven/iterables";
 import { createObject } from "@coven/utils";
 import { assertEquals } from "@std/assert";
+import { compare } from "../compare.ts";
+import { CREATE_KIND } from "../CREATE_KIND.ts";
+import { DELETE_KIND } from "../DELETE_KIND.ts";
+import { flat } from "../flat.ts";
+import { UPDATE_KIND } from "../UPDATE_KIND.ts";
 
 const property1 = "property1";
 const property2 = "property2";
@@ -191,66 +189,24 @@ Deno.test(
 
 Deno.test(
 	"Comparing a real array and a fake array yields `DeleteDifference`s",
-	() =>
-		assertEquals(
-			flat(
-				compare(["coven"])(
-					createObject({
-						0: "coven",
-						constructor: Array,
-						length: 1,
-					}),
-				),
-			),
-			(
-				[
-					"at",
-					"concat",
-					"copyWithin",
-					"fill",
-					"find",
-					"findIndex",
-					"findLast",
-					"findLastIndex",
-					"lastIndexOf",
-					"pop",
-					"push",
-					"reverse",
-					"shift",
-					"unshift",
-					"slice",
-					"sort",
-					"splice",
-					"includes",
-					"indexOf",
-					"join",
-					"keys",
-					"entries",
-					"values",
-					"forEach",
-					"filter",
-					"flat",
-					"flatMap",
-					"map",
-					"every",
-					"some",
-					"reduce",
-					"reduceRight",
-					"toReversed",
-					"toSorted",
-					"toSpliced",
-					"with",
-					"toLocaleString",
-					"toString",
-					Symbol.iterator,
-					Symbol.unscopables,
-				] as const
-			).map((key) => ({
-				kind: DELETE_KIND,
-				left: Array.prototype[key],
-				path: [key],
-			})) as ReturnType<typeof flat>,
-		),
+	() => {
+		const fakeArray = createObject({
+			0: "coven",
+			constructor: Array,
+			length: 1,
+		});
+
+		return assertEquals(
+			flat(compare(["coven"])(fakeArray)),
+			Reflect.ownKeys(Array.prototype)
+				.filter((key) => !Reflect.ownKeys(fakeArray).includes(key))
+				.map((key) => ({
+					kind: DELETE_KIND,
+					left: Array.prototype[key as keyof typeof Array.prototype],
+					path: [key],
+				})) as ReturnType<typeof flat>,
+		);
+	},
 );
 
 Deno.test("Comparing 0 with -0 should yield `UpdateDifference`", () =>

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

@@ -1,5 +1,7 @@
-import { DELETE_KIND, flat, pathPrepend } from "@coven/compare";
 import { assertEquals } from "@std/assert";
+import { DELETE_KIND } from "../DELETE_KIND.ts";
+import { flat } from "../flat.ts";
+import { pathPrepend } from "../pathPrepend.ts";
 
 const prepend13 = pathPrepend(13);
 

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

@@ -1,10 +1,8 @@
-import { differentiate, flat, MISSING_VALUE } from "@coven/compare";
-import { EMPTY_ARRAY } from "@coven/constants";
+import { EMPTY_ARRAY, SIGIL } from "@coven/constants";
 import { assertEquals } from "@std/assert";
+import { differentiate } from "../differentiate.ts";
+import { flat } from "../flat.ts";
 
 Deno.test("When both values are missing returns an empty difference", () =>
-	assertEquals(
-		flat(differentiate(MISSING_VALUE)(MISSING_VALUE)),
-		EMPTY_ARRAY,
-	),
+	assertEquals(flat(differentiate(SIGIL)(SIGIL)), EMPTY_ARRAY),
 );

@coven/constants/README.md

@@ -18,14 +18,17 @@ mutations throws.
 
 - `EMPTY_ARRAY`: Empty read-only array.
 - `EMPTY_OBJECT`: Empty read-only `null` prototype object.
+- `SIGIL`: Internal value to be used as bottom value (like `null` and
+  `undefined`) when native bottom values have to be used.
 
 ## Example
 
 ```typescript
-import { EMPTY_ARRAY, EMPTY_OBJECT } from "@coven/constants";
+import { EMPTY_ARRAY, EMPTY_OBJECT, SIGIL } from "@coven/constants";
 
 console.log(EMPTY_ARRAY); // []
 console.log(EMPTY_OBJECT); // {}
+console.log(SIGIL); // Symbol("⛧")
 ```
 
 ## Other links

@coven/constants/SIGIL.ts

@@ -0,0 +1,5 @@
+/**
+ * Internal value to be used as bottom value (like `null` and `undefined`) when
+ * native bottom values have to be used for something else.
+ */
+export const SIGIL: unique symbol = Symbol.for("⛧");

@coven/constants/deno.json

@@ -2,5 +2,5 @@
 	"$schema": "https://raw.githubusercontent.com/denoland/deno/main/cli/schemas/config-file.v1.json",
 	"exports": "./mod.ts",
 	"name": "@coven/constants",
-	"version": "0.8.5"
+	"version": "0.9.0"
 }

@coven/constants/mod.ts

@@ -1,2 +1,3 @@
 export { EMPTY_ARRAY } from "./EMPTY_ARRAY.ts";
 export { EMPTY_OBJECT } from "./EMPTY_OBJECT.ts";
+export { SIGIL } from "./SIGIL.ts";

@coven/constants/tests/EMPTY_ARRAY.test.ts

@@ -1,5 +1,5 @@
-import { EMPTY_ARRAY } from "@coven/constants";
 import { assertThrows } from "@std/assert";
+import { EMPTY_ARRAY } from "../EMPTY_ARRAY.ts";
 
 Deno.test(
 	"`Array#pop` should throw",

@coven/constants/tests/EMPTY_OBJECT.test.ts

@@ -1,5 +1,5 @@
-import { EMPTY_OBJECT } from "@coven/constants";
 import { assertThrows } from "@std/assert";
+import { EMPTY_OBJECT } from "../EMPTY_OBJECT.ts";
 
 Deno.test(
 	"Trying direct mutations should throw",

@coven/cron/compareField.ts

@@ -1,4 +1,4 @@
-import { memo } from "@coven/memo";
+import { memoFunction } from "@coven/memo";
 import type { AllToken } from "./AllToken.ts";
 import type { Field } from "./Field.ts";
 import { compareRangeOrValue } from "./compareRangeOrValue.ts";
@@ -25,8 +25,9 @@ import { isListField } from "./isListField.ts";
 export const compareField: (
 	value: number,
 	field: Exclude<Field<number>, AllToken>,
-) => boolean = memo((value: number, field: Exclude<Field<number>, AllToken>) =>
-	isListField(field) ?
-		field.some(compareRangeOrValue(value))
-	:	compareRangeOrValue(value)(field),
+) => boolean = memoFunction(
+	(value: number, field: Exclude<Field<number>, AllToken>) =>
+		isListField(field) ?
+			field.some(compareRangeOrValue(value))
+		:	compareRangeOrValue(value)(field),
 );

@coven/cron/compareRangeOrValue.ts

@@ -1,4 +1,4 @@
-import { memo } from "@coven/memo";
+import { memoFunction } from "@coven/memo";
 import type { ValueOrRangeField } from "./ValueOrRangeField.ts";
 import { isRangeField } from "./isRangeField.ts";
 
@@ -17,9 +17,9 @@ import { isRangeField } from "./isRangeField.ts";
  */
 export const compareRangeOrValue: (
 	value: number,
-) => (valueOrRange: ValueOrRangeField<number>) => boolean = memo(
+) => (valueOrRange: ValueOrRangeField<number>) => boolean = memoFunction(
 	(value: number): ((valueOrRange: ValueOrRangeField<number>) => boolean) =>
-		memo((valueOrRange) =>
+		memoFunction((valueOrRange) =>
 			isRangeField(valueOrRange) ?
 				value >= valueOrRange.from && value <= valueOrRange.to
 			:	value === valueOrRange,

@coven/cron/deno.json

@@ -2,5 +2,5 @@
 	"$schema": "https://raw.githubusercontent.com/denoland/deno/main/cli/schemas/config-file.v1.json",
 	"exports": "./mod.ts",
 	"name": "@coven/cron",
-	"version": "0.8.5"
+	"version": "0.9.0"
 }

@coven/cron/fieldRegExp.ts

@@ -1,5 +1,5 @@
 import { captureNamed, disjunction, escape } from "@coven/expression";
-import { memo } from "@coven/memo";
+import { memoFunction } from "@coven/memo";
 import { ALL_TOKEN } from "./tokens.ts";
 import { valueRangeOrListRegExp } from "./valueRangeOrListRegExp.ts";
 
@@ -18,7 +18,7 @@ export const fieldRegExp: <Name extends string, Value extends string>(
 	name: Name,
 	value: Value,
 ) => `(?<${Name}>\\*|(?:${Value}(?:-${Value})?|(?:(?:${Value}(?:-${Value})?,)+${Value}(?:-${Value})?)))` =
-	memo(
+	memoFunction(
 		<Name extends string, Value extends string>(name: Name, value: Value) =>
 			captureNamed(name)(
 				disjunction(escape(ALL_TOKEN), valueRangeOrListRegExp(value)),

@coven/cron/isListField.ts

@@ -1,5 +1,5 @@
 import { every } from "@coven/iterables";
-import { memo } from "@coven/memo";
+import { memoFunction } from "@coven/memo";
 import { isArray, isNumber } from "@coven/predicates";
 import type { Field } from "./Field.ts";
 import { isRangeField } from "./isRangeField.ts";
@@ -18,7 +18,7 @@ const everyIsNumberOrRangeField = every<
  * @see {@linkcode isRangeField}
  */
 export const isListField: (value: Field<number>) => value is ListField<number> =
-	memo(
+	memoFunction(
 		(value: Field<number>) =>
 			isArray(value) && everyIsNumberOrRangeField(value),
 	);