create statically typed variant of versioning lib

lib/versioning/static/compare.js

@@ -0,0 +1,55 @@
+import { compareSymbols, compareInts } from "../../compare/primitives.js";
+import { compareFunctions } from "../../compare/structures.js";
+import { makeTypeParser } from "../../parser/type_parser.js";
+import { newDynamic } from "../../primitives/dynamic.js";
+import { makeEnumCompareFn } from "../../structures/enum.js";
+import { makeStructCompareFn } from "../../structures/struct.js";
+import { Slot, Transformation, Value, Write } from "./value_slot.js";
+
+
+// comparison functions are mutually recursive...
+
+export const compareSlot = compareElems => makeEnumCompareFn([
+  { l: "new", r: () => compareSymbols },
+  { l: "write", r: () => compareWrite(compareElems) },
+]);
+
+export const compareWrite = compareElems => makeStructCompareFn([
+  { l: "slot", r: () => compareSlot(compareElems) },
+  { l: "value", r: () => compareValue(compareElems) },
+  { l: "depth", r: () => compareInts },
+]);
+
+export const compareTransformation = compareInputs => compareOutputs => makeStructCompareFn([
+  { l: "input", r: () => compareValue(compareInputs) },
+  { l: "fn", r: () => compareValue(compareFunctions(compareInputs)(compareOutputs)) },
+  { l: "output", r: () => compareOutputs },
+]);
+
+export const compareValue = compareElems => makeEnumCompareFn([
+  { l: "literal", r: () => compareElems },
+  { l: "read", r: () => compareWrite(compareElems) },
+  { l: "transform", r: () =>
+    compareTransformation
+      (_a => _b => 0) // <- we cheat here, because we don't statically know the input type of the transformation.
+      (compareElems) },
+]);
+
+const mkType = makeTypeParser({
+  extraBracketOperators: [
+    [':=', ['=:', Slot]],
+    ['*=', ['=*', Value]],
+    ['*:=', ['=:*', Write]],
+  ],
+  extraInfixOperators: [
+    ['===>', Transformation],
+  ],
+});
+
+export const ModuleVersioningCompare = [
+  // comparison
+  ["compareSlot" , newDynamic(compareSlot )(mkType("(a -> a -> Ordering) ->  :=a=:  ->  :=a=:  -> Ordering"))],
+  ["compareValue", newDynamic(compareValue)(mkType("(a -> a -> Ordering) ->  *=a=*  ->  *=a=*  -> Ordering"))],
+  ["compareWrite", newDynamic(compareWrite)(mkType("(a -> a -> Ordering) -> *:=a=:* -> *:=a=:* -> Ordering"))],
+  ["compareTransformation", newDynamic(compareTransformation)(mkType("(a -> a -> Ordering) -> (b -> b -> Ordering) -> (a ===> b) -> (a ===> b) -> Ordering"))],
+];