@fraczak/k 6.0.3 → 6.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.0.3",
+    "version": "6.0.4",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {

package/repl2.mjs

@@ -19,7 +19,8 @@ import {
   encodeObject,
   encodeLibrary,
   hydrateObject,
-  loadLibrary
+  loadLibrary,
+  prettyRelation
 } from "./object.mjs";
 import { propertyListToFilter, valueToK, valueWithEnvelopeToK } from "./codecs/runtime/show-value.mjs";
 
@@ -58,7 +59,6 @@ function createState() {
 function stateLibrary(state) {
   return {
     format: "k-object",
-    version: 2,
     codes: state.codes,
     rels: state.rels,
     relAlias: state.relAliases,
@@ -149,11 +149,7 @@ function mergeMeta(state, meta = {}) {
     const entryType = entry?.type;
     if (!state.meta[hash]) state.meta[hash] = { type: entryType, origins: [] };
     if (state.meta[hash].type == null && entryType != null) state.meta[hash].type = entryType;
-    state.meta[hash].origins.push(...origins.map(({ source, name, compiledAt }) => ({
-      source,
-      name,
-      ...(compiledAt == null ? {} : { compiledAt })
-    })));
+    state.meta[hash].origins.push(...origins.map((origin) => ({ ...origin })));
   }
 }
 
@@ -220,7 +216,6 @@ function savedLibrary(state) {
   }
   return {
     format: "k-object",
-    version: 2,
     codes: state.codes,
     rels: state.rels,
     relAlias: state.relAliases,
@@ -289,6 +284,16 @@ function userDefinedNames(source) {
   };
 }
 
+function originFromSourceNode(source, name, compiledAt, node) {
+  return {
+    source,
+    name,
+    compiledAt,
+    ...(node?.start ? { start: node.start } : {}),
+    ...(node?.end ? { end: node.end } : {})
+  };
+}
+
 function libraryOriginsFromSource(source, fullSource, lib, options) {
   const { typeNames, relNames } = userDefinedNames(source);
   const annotated = annotateWithOptionalIdentity(fullSource, options);
@@ -299,7 +304,12 @@ function libraryOriginsFromSource(source, fullSource, lib, options) {
     const hash = annotated.representatives?.[name];
     if (!hash) continue;
     if (!meta[hash]) meta[hash] = { type: "code", origins: [] };
-    meta[hash].origins.push({ source: options.source || null, name, compiledAt: now });
+    meta[hash].origins.push(originFromSourceNode(
+      options.source || null,
+      name,
+      now,
+      annotated.sourceDefs?.codes?.[name]
+    ));
   }
 
   const relAlias = Object.fromEntries(
@@ -310,7 +320,12 @@ function libraryOriginsFromSource(source, fullSource, lib, options) {
 
   for (const [name, hash] of Object.entries(relAlias)) {
     if (!meta[hash]) meta[hash] = { type: "rel", origins: [] };
-    meta[hash].origins.push({ source: options.source || null, name, compiledAt: now });
+    meta[hash].origins.push(originFromSourceNode(
+      options.source || null,
+      name,
+      now,
+      annotated.rels?.[name]?.def
+    ));
   }
 
   return { relAlias, meta };
@@ -788,7 +803,7 @@ async function evaluateCommand(line, state) {
       if (!arg) throw new Error(`${usagePrefix}d requires a relation name`);
       const { hash, rel } = resolveRel(state, arg);
       if (!rel) throw new Error(`Unknown relation '${arg}'`);
-      return [`${arg} = ${prettyRel(rel.def)};  -- ${hash}`];
+      return [`${arg} = ${prettyRelation(rel)};  -- ${hash}`];
     }
     case "C": {
       if (!arg) throw new Error(`${usagePrefix}C requires a type name`);

package/run.mjs

@@ -166,7 +166,7 @@ function compiledExp(findCode, exp, typePatternGraph) {
       {
         const defn = run.defs.rels[exp.ref];
         if (defn != undefined) {
-          const refFn = compiledExp(findCode, defn.def, defn.typePatternGraph);
+          const refFn = compiledRel(findCode, defn, exp.ref);
           fn = (value) => {
             return value === undefined ? undefined : refFn(value);
           };
@@ -266,6 +266,161 @@ function compiledExp(findCode, exp, typePatternGraph) {
   return compiled.fn;
 }
 
+function compiledRel(findCode, relDef, name = "<anonymous>") {
+  const cached = relDef._compiledRunRel;
+  if (cached?.findCode === findCode && cached?.defs === run.defs) {
+    return cached.fn;
+  }
+
+  const compiled = {
+    findCode,
+    defs: run.defs,
+    target: null,
+    fn(value) {
+      return compiled.target(value);
+    }
+  };
+  relDef._compiledRunRel = compiled;
+
+  const exp = relDef.def;
+  const typePatternGraph = relDef.typePatternGraph || null;
+  const inputPattern = staticPattern(typePatternGraph, exp, 0);
+  const staticOutputPattern = outputPattern(typePatternGraph, exp);
+  const bodyFn = compiledExp(findCode, exp, typePatternGraph);
+
+  compiled.target = (value) => {
+    if (value === undefined) return undefined;
+    value = constrainWithPattern(value, inputPattern, exp);
+    const result = bodyFn(value);
+    if (result === undefined) return undefined;
+    try {
+      return constrainWithPattern(result, staticOutputPattern, exp);
+    } catch (error) {
+      error.message = `Type Error in output of '${name}'\n - ${error.message}`;
+      throw error;
+    }
+  };
+  return compiled.fn;
+}
+
+function assertConvergedRel(rel, name) {
+  const status = rel?.typeDerivation?.status || "unknown";
+  if (status !== "converged") {
+    throw new Error(`Cannot run '${name}' without envelopes: type derivation is ${status}`);
+  }
+}
+
+function compiledConvergedExp(findCode, exp, typePatternGraph, options = {}) {
+  const requireConverged = options.requireConverged === true;
+  const cached = exp._compiledConvergedRun;
+  if (
+    cached?.findCode === findCode &&
+    cached?.typePatternGraph === typePatternGraph &&
+    cached?.defs === run_converged.defs &&
+    cached?.requireConverged === requireConverged
+  ) {
+    return cached.fn;
+  }
+
+  const compiled = {
+    findCode,
+    typePatternGraph,
+    defs: run_converged.defs,
+    requireConverged,
+    target: null,
+    fn(value) {
+      return compiled.target(value);
+    }
+  };
+  exp._compiledConvergedRun = compiled;
+
+  let fn;
+  switch (exp.op) {
+    case "code":
+    case "filter":
+    case "identity":
+      fn = (value) => value;
+      break;
+    case "ref":
+      {
+        const defn = run_converged.defs?.rels?.[exp.ref];
+        if (defn != undefined) {
+          if (requireConverged) assertConvergedRel(defn, exp.ref);
+          const refFn = compiledConvergedExp(findCode, defn.def, defn.typePatternGraph, options);
+          fn = (value) => value === undefined ? undefined : refFn(value);
+        } else {
+          const builtin_func = builtin[exp.ref];
+          if (builtin_func != null) {
+            fn = (value) => value === undefined ? undefined : builtin_func(value);
+          } else {
+            fn = () => {
+              throw(`Unknown ref: '${exp.ref}'`);
+            };
+          }
+        }
+      }
+      break;
+    case "dot":
+      fn = (value) => {
+        if (value === undefined || !(value instanceof Product)) return undefined;
+        return Object.hasOwn(value.product, exp.dot) ? value.product[exp.dot] : undefined;
+      };
+      break;
+    case "div":
+      fn = (value) => {
+        if (value === undefined || !(value instanceof Variant) || value.tag !== exp.div) return undefined;
+        return value.value;
+      };
+      break;
+    case "comp": {
+      const parts = exp.comp.map((part) => compiledConvergedExp(findCode, part, typePatternGraph, options));
+      fn = (value) => {
+        for (let i = 0, len = parts.length; i < len; i++) {
+          value = parts[i](value);
+          if (value === undefined) return undefined;
+        }
+        return value;
+      };
+      break;
+    }
+    case "union": {
+      const parts = exp.union.map((part) => compiledConvergedExp(findCode, part, typePatternGraph, options));
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        for (let i = 0, len = parts.length; i < len; i++) {
+          const result = parts[i](value);
+          if (result !== undefined) return result;
+        }
+        return undefined;
+      };
+      break;
+    }
+    case "product": {
+      const labels = exp.product.map(({ label }) => label);
+      const fieldFns = exp.product.map(({ exp: e }) => compiledConvergedExp(findCode, e, typePatternGraph, options));
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        const result = {};
+        for (let i = 0, len = labels.length; i < len; i++) {
+          const r = fieldFns[i](value);
+          if (r === undefined) return undefined;
+          result[labels[i]] = r;
+        }
+        return new Product(result);
+      };
+      break;
+    }
+    case "vid":
+      fn = (value) => value === undefined ? undefined : new Variant(exp.vid, value);
+      break;
+    default:
+      assert(false,`Unknown operation: '${exp.op}'`);
+  }
+
+  compiled.target = fn;
+  return compiled.fn;
+}
+
 function verify(findCode, code, value) {
   "use strict";
   if (code == null) return false;
@@ -296,7 +451,22 @@ function run(findCode, exp, value, typePatternGraph) {
   return compiledExp(findCode, exp, typePatternGraph || null)(value);
 }
 
+function run_rel(findCode, relDef, value, name) {
+  return compiledRel(findCode, relDef, name)(value);
+}
+
+function run_converged(findCode, exp, value, typePatternGraph, options = {}) {
+  const graph = typePatternGraph || null;
+  const result = compiledConvergedExp(findCode, exp, graph, options)(value);
+  if (result === undefined) return undefined;
+  return withPattern(result, outputPattern(graph, exp));
+}
+
 run.builtin = builtin;
+run_converged.builtin = builtin;
+run_converged.defs = null;
+
+const run_coverged = run_converged;
 
 export default run;
-export { run  };
+export { run, run_rel, run_converged, run_coverged };

package/test-k-object.mjs

@@ -11,6 +11,7 @@ import {
   compileLibraryBuffer,
   decodeObject,
   objectToFunction,
+  runConvergedObject,
   decompileObjectBuffer,
   extractAliasesFromObject
 } from "./object.mjs";
@@ -54,10 +55,30 @@ const objectBuffer = compileObjectBuffer(`
   $ int = < bits +, bits - >;
   {}|_|0|1|+ $int
 `);
-const objectFn = objectToFunction(decodeObject(objectBuffer));
+assert.equal(objectBuffer.subarray(0, 5).toString("utf8"), "KOBJ\n");
+const object = decodeObject(objectBuffer);
+assert.equal("version" in object, false);
+assert(Object.values(object.codes).every((code) => code.typeDerivation == null));
+assert.equal(JSON.stringify(object.codes).includes('"start"'), false);
+assert.equal(JSON.stringify(object.codes).includes('"end"'), false);
+assert.equal(JSON.stringify(object.meta).includes('"spans"'), false);
+assert(Object.values(object.rels).every((rel) =>
+  JSON.stringify(Object.keys(rel.typeDerivation || {}).sort()) === JSON.stringify(["status"]) &&
+  rel.typeDerivation.status === "converged"
+));
+assert.notEqual(object.rels.__main__.def.comp?.[0]?.op, "filter");
+assert.equal(JSON.stringify(object.rels.__main__.def).includes('"start"'), false);
+assert(object.meta[object.relAlias.__main__]?.origins?.some((origin) =>
+  origin.name === "__main__" && origin.start && origin.end
+));
+
+const objectFn = objectToFunction(object);
 const objectResult = objectFn(new Product({}));
 assert.deepEqual(objectResult.pattern, INT_PATTERN);
 assert.deepEqual(objectResult.toJSON(), { "+": { "1": { "0": "_" } } });
+const convergedObjectResult = runConvergedObject(object, new Product({}));
+assert.deepEqual(convergedObjectResult.pattern, INT_PATTERN);
+assert.deepEqual(convergedObjectResult.toJSON(), objectResult.toJSON());
 
 const decompiledSource = decompileObjectBuffer(objectBuffer);
 const decompiledResult = k.compile(decompiledSource)(new Product({}));
@@ -78,15 +99,28 @@ const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a
 assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
 assert.deepEqual(k.compile(sccSource)(new Product({})).toJSON(), { y: "x" });
 
-const library = decodeObject(compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" }));
+const libraryBuffer = compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" });
+assert.equal(libraryBuffer.subarray(0, 1).toString("utf8"), "{");
+const library = decodeObject(libraryBuffer);
+assert.equal("version" in library, false);
 assert.equal(library.main, null);
+assert(Object.values(library.codes).every((code) => code.typeDerivation == null));
+assert.equal(JSON.stringify(library.codes).includes('"start"'), false);
+assert.equal(JSON.stringify(library.codes).includes('"end"'), false);
+assert.equal(JSON.stringify(library.meta).includes('"spans"'), false);
+assert(Object.values(library.rels).every((rel) =>
+  JSON.stringify(Object.keys(rel.typeDerivation || {}).sort()) === JSON.stringify(["status"]) &&
+  rel.typeDerivation.status === "converged"
+));
+assert(Object.values(library.rels).every((rel) => rel.def.op !== "comp" || rel.def.comp[0]?.op !== "filter"));
 assert(Object.values(library.meta).some(({ type, origins }) =>
   type === "code" &&
   origins.some((origin) =>
     origin.source === "defs-only.k" &&
     origin.name === "nat" &&
-    JSON.stringify(Object.keys(origin).sort()) === JSON.stringify(["compiledAt", "name", "source"]) &&
-    typeof origin.compiledAt === "string"
+    typeof origin.compiledAt === "string" &&
+    origin.start &&
+    origin.end
   )
 ));
 assert(Object.values(library.meta).some(({ type, origins }) =>
@@ -94,8 +128,9 @@ assert(Object.values(library.meta).some(({ type, origins }) =>
   origins.some((origin) =>
     origin.source === "defs-only.k" &&
     origin.name === "succ" &&
-    JSON.stringify(Object.keys(origin).sort()) === JSON.stringify(["compiledAt", "name", "source"]) &&
-    typeof origin.compiledAt === "string"
+    typeof origin.compiledAt === "string" &&
+    origin.start &&
+    origin.end
   )
 ));
 
@@ -110,9 +145,25 @@ assert.match(derivedAliases, /^other = @/m);
 assert(derivedAliases.indexOf("$ nat = @") < derivedAliases.indexOf("other = @"));
 assert(derivedAliases.indexOf("other = @") < derivedAliases.indexOf("succ = @"));
 
+{
+  const warn = console.warn;
+  console.warn = () => {};
+  try {
+    const nonConverged = decodeObject(compileObjectBuffer("f = .x f; f", {
+      convergence: { strategy: "fixed_point", maxIterations: 1 }
+    }));
+    assert.equal(nonConverged.rels.__main__.typeDerivation.status, "not-converged");
+    assert.throws(
+      () => runConvergedObject(nonConverged, new Product({ x: new Product({}) })),
+      /type derivation is not-converged/
+    );
+  } finally {
+    console.warn = warn;
+  }
+}
+
 const aliasSnippet = extractAliasesFromObject({
   format: "k-object",
-  version: 2,
   codes: {},
   rels: {},
   meta: {