@fraczak/k 5.1.2 → 6.0.0

package/codes.mjs

@@ -1,6 +1,5 @@
 import hash from "./hash.mjs";
 
-
 const theRepository = { codes: {  } };
 
 const unitCode = function() {
@@ -8,36 +7,18 @@ const unitCode = function() {
   return hash(unitCodeDef);
 }();
 
-function isBuiltIn(code) {  
-  return code.match(/^@(int|string|bool)$/);
-}
+theRepository.codes[unitCode] = { code: "product", product: {} };
 
 function encodeCodeToString(code, codes = theRepository.codes) {
-  if (isBuiltIn(code)) return code;
-  var i = 0;
+  let i = 0;
   const Q = [[code,i]];
   const D = {[code]: i++};
-  var result=[];
+  let result=[];
   while (Q.length > 0) {
     const [x,c] = Q.shift();
     const c_code = codes[x];
-    if (c_code.code == "vector") {
-      const u_arg = c_code.vector;
-      if (isBuiltIn(u_arg)) {
-        result.push(`$C${result.length}=[${u_arg}];`);
-        continue;
-      }
-      if (D[u_arg] === undefined) {
-        Q.push([u_arg,i]);
-        D[u_arg] = i++;
-      }
-      result.push(`$C${result.length}=[C${D[u_arg]}];`);
-      continue;
-    }
     const u_args =  Object.keys(c_code[c_code.code]).sort().map((k) => {
       const u_arg = c_code[c_code.code][k];
-      if (isBuiltIn(u_arg)) 
-        return `${u_arg}${JSON.stringify(k)}`;
       if (D[u_arg] === undefined) {
         Q.push([u_arg,i]);
         D[u_arg] = i++;
@@ -79,22 +60,20 @@ function are_different(classes, representatives, name1, name2, codes) {
       for (const field in fields1) {
         if (fields2[field] !== fields1[field]) return true;
       }
-      break;
-    case "vector":
-      const [arg1, arg2] = [code1, code2].map(
-        ({ vector }) => representatives[vector] || vector
-      );
-      if (arg1 !== arg2) return true;
   }
   return false;
 }
 
 function minimize(codes) {
   const names = Object.keys(codes);
+  if (names.length === 0) {
+    return { classes: {}, representatives: {} };
+  }
   const classes = {};
-  classes[unitCode] = names;
+  const seed = names.includes(unitCode) ? unitCode : names[0];
+  classes[seed] = names;
   const representatives = names.reduce((representatives, name) => {
-    representatives[name] = unitCode;
+    representatives[name] = seed;
     return representatives;
   }, {});
   let changed = true;
@@ -127,6 +106,34 @@ function minimize(codes) {
   return { classes, representatives };
 }
 
+function resolveRefs(codes) {
+  const resolved = {};
+  
+  for (const name in codes) {
+    const code = codes[name];
+    if (code.code === "ref" && code.ref.startsWith("@")) {
+      // This is an alias to a canonical type (by name or by hash)
+      const refName = code.ref.substring(1); // Remove the @ prefix
+      
+      // Check if it's a reference to a user-defined type in the current codes
+      if (codes[refName] !== undefined) {
+        resolved[name] = refName;
+      } 
+      // Check if it's a reference to an existing canonical hash in the repository
+      else if (theRepository.codes[code.ref] !== undefined) {
+        resolved[name] = code.ref;
+      } 
+      else {
+        throw new Error(`Type alias references undefined type: ${code.ref}`);
+      }
+    } else {
+      resolved[name] = name;
+    }
+  }
+  
+  return resolved;
+}
+
 function normalize(label_ref_map, representatives) {
   return Object.keys(label_ref_map).reduce((result, label) => {
     const name = label_ref_map[label];
@@ -148,12 +155,9 @@ function normalizeAll(codes, representatives) {
             representatives
           );
           break;
-        case "vector":
-          normalized[name] = {
-            ...code,
-            vector: representatives[code.vector] || code.vector,
-          };
-          break;
+        case "ref":
+          // Ref codes should have been resolved in finalize, this shouldn't happen
+          throw new Error(`Unresolved type alias: ${code.ref}`);
         default:
           throw new Error(`Unexpected code ${code.code}`);
       }
@@ -164,8 +168,41 @@ function normalizeAll(codes, representatives) {
 }
 
 function finalize(codes) {
-  const representatives = minimize(codes).representatives;
-  const normalizedCodes = normalizeAll(codes, representatives);
+  // First, resolve all @name references to their actual code definitions
+  const refResolution = resolveRefs(codes);
+  const resolvedCodes = {};
+  
+  for (const name in codes) {
+    const code = codes[name];
+    if (code.code === "ref" && code.ref.startsWith("@")) {
+      // This is an alias, use the resolved target's code
+      const target = refResolution[name];
+      
+      // Check if target is a canonical hash (starts with @)
+      if (target.startsWith("@")) {
+        // Reference to existing canonical hash in repository
+        resolvedCodes[name] = theRepository.codes[target];
+      } else {
+        // Reference to a user-defined type in current codes
+        resolvedCodes[name] = codes[target];
+      }
+    } else {
+      resolvedCodes[name] = code;
+    }
+  }
+  
+  const representatives = minimize(resolvedCodes).representatives;
+  
+  // Also update representatives to account for aliases
+  // If name was aliased to target, and target maps to rep, then name should map to rep
+  for (const name in refResolution) {
+    if (refResolution[name] !== name) {
+      const target = refResolution[name];
+      representatives[name] = representatives[target] || target;
+    }
+  }
+  
+  const normalizedCodes = normalizeAll(resolvedCodes, representatives);
   const globalNames = Object.keys(normalizedCodes).reduce((globalNames, name) => {
     const globalDef = encodeCodeToString(name, normalizedCodes);
     normalizedCodes[name].def = globalDef;
@@ -193,22 +230,87 @@ function finalize(codes) {
   };
 }
 
+function finalizeIncremental(newCodes) {
+  const refResolution = resolveRefs(newCodes);
+  const resolvedCodes = {};
+
+  for (const name in newCodes) {
+    const code = newCodes[name];
+    if (code.code === "ref" && code.ref.startsWith("@")) {
+      const target = refResolution[name];
+      if (target.startsWith("@")) {
+        resolvedCodes[name] = theRepository.codes[target];
+      } else {
+        resolvedCodes[name] = newCodes[target];
+      }
+    } else {
+      resolvedCodes[name] = code;
+    }
+  }
+
+  const representatives = minimize(resolvedCodes).representatives;
+  for (const name in refResolution) {
+    if (refResolution[name] !== name) {
+      const target = refResolution[name];
+      representatives[name] = representatives[target] || target;
+    }
+  }
+
+  const normalizedCodes = normalizeAll(resolvedCodes, representatives);
+  const allReadableCodes = { ...theRepository.codes, ...normalizedCodes };
+  const globalNames = {};
+
+  for (const name in normalizedCodes) {
+    const globalDef = encodeCodeToString(name, allReadableCodes);
+    normalizedCodes[name].def = globalDef;
+    globalNames[name] = hash(globalDef);
+  }
+
+  const globalCodes = Object.keys(normalizedCodes).reduce((result, name) => {
+    result[globalNames[name]] = normalizedCodes[name];
+    return result;
+  }, {});
+
+  const extendedRepresentatives = Object.keys(representatives).reduce((result, name) => {
+    result[name] = globalNames[representatives[name]] || representatives[name] || name;
+    return result;
+  }, {});
+
+  Object.values(globalNames).forEach((name) => {
+    extendedRepresentatives[name] = name;
+  });
+
+  const normalizedGlobalCodes = normalizeAll(globalCodes, extendedRepresentatives);
+  return {
+    codes: normalizedGlobalCodes,
+    representatives: extendedRepresentatives
+  };
+}
+
 function register(newCodes) {
-  const { codes, representatives } = finalize( {...theRepository.codes,...newCodes});
+  const { codes, representatives } = finalizeIncremental(newCodes);
   const reps = Object.values(representatives).reduce((reps,rep) => 
     ({...reps, [rep]:rep})
   , {});
   for (const rep in reps) {
-    theRepository.codes[rep] = codes[rep];
+    if (codes[rep] !== undefined) {
+      theRepository.codes[rep] = codes[rep];
+    }
   };
   return representatives;
 }
 
 function find(codeName) {
-  if (isBuiltIn(codeName))
-    return {code: codeName, def: "builtin"};
   return JSON.parse(JSON.stringify(theRepository.codes[codeName] || {code: "undefined"}));
 };
 
-export default { minimize, normalize, normalizeAll, encodeCodeToString, finalize, unitCode, register, find };
-export { minimize, normalize, normalizeAll, encodeCodeToString, finalize, unitCode, register, find };
+function load(dump) {
+  theRepository.codes = dump;
+}
+
+function dump() {
+  return JSON.parse(JSON.stringify(theRepository.codes));
+}
+
+export default { minimize, normalize, normalizeAll, encodeCodeToString, finalize, unitCode, register, find, load, dump };
+export { minimize, normalize, normalizeAll, encodeCodeToString, finalize, unitCode, register, find, load, dump };

package/compiler.mjs

@@ -0,0 +1,111 @@
+import hash from "./hash.mjs";
+import { TypePatternGraph } from "./TypePatternGraph.mjs";
+import { Graph, sccs, topoOrder } from "./Graph.mjs";
+import codes from "./codes.mjs";
+import { augment } from "./augmentation.mjs";
+import { assignCanonicalNames } from "./export.mjs";
+import { convergeScc, relDefToString } from "./convergence.mjs";
+
+function compileTypes(representatives, rels, options = {}) {
+  // INPUT: 
+  //   representatives: {"{}": "KL", ...} - mapping from types to their canonical names
+  //   rels: {"rlz": {def: {op: comp,...}, ...}, ...} - relation definitions
+  //   options: {
+  //     convergence: {
+  //       strategy: "auto" | "single_pass" | "fixed_point",  // type derivation strategy
+  //       maxIterations: number  // max iterations for fixed_point (default: 2 + scc.length)
+  //     }
+  //   }
+ 
+  const relAlias = {};
+  const compileStats = {
+    sccs: []
+  };
+
+  // 1 INITIALIZATION
+  // 1.1 initialize patternNodes and rels
+  // ==================================================================================
+  // ----------------------------------------------------------------------------------
+  // 1. Initialize the typePatternGraph and varRefs for each relation
+
+  for (const relName in rels) {
+    const rootDef = rels[relName];
+    // Skip already-compiled rels (e.g., from loaded libraries)
+    if (rootDef._library) continue;
+    rootDef.typePatternGraph = new TypePatternGraph(codes.register, codes.find);
+    rootDef.varRefs = []; // the list of references to non-builtin rels as pointers to AST nodes
+    rootDef.patternVars = {};
+    rootDef.rels = rels;
+    rootDef.representatives = representatives; 
+    augment(rootDef.def, rootDef, rels, representatives);
+    delete rootDef.patternVars;
+    delete rootDef.rels;
+    delete rootDef.representatives;
+  }
+   
+  
+  // 2. Compute DAG of strongly connected components in varRefs
+  //    A rel_1 -> rel_2 if rel1,varRefs contains a reference to {op: "ref", ref: rel_2}
+  
+  const graph = new Graph(
+    // 1st argument: edges
+    [].concat(...Object.keys(rels).map( relName => 
+      (rels[relName].varRefs || []).map( ({varName}) => 
+        ({src: relName, dst: varName})))),
+    // 2nd argument: vertices
+    rels
+  );
+
+  const sccs_ = sccs(graph);
+
+  const DAGnodes = sccs_.reduce ((nodes, scc) => 
+    ({...nodes, [scc[0]]: {scc}}), {});
+  const fromRelNameToDAGnode = Object.keys(DAGnodes).reduce((map, node) =>
+    DAGnodes[node].scc.reduce((map, relName) => ({...map, [relName]: node}), map), {});
+  const DAGedges = [].concat(
+    ...Object.keys(rels).map( x =>
+      (rels[x].varRefs || []).map(({ varName }) => 
+        ({src: fromRelNameToDAGnode[x], dst: fromRelNameToDAGnode[varName]})
+      ) // don't forget to remove loops
+      .filter(({src, dst}) => src !== dst )
+    )
+  );
+  const DAG = new Graph(DAGedges, DAGnodes);
+
+  // 3. Topological sort of the DAG
+
+  const sccInOrder = topoOrder(DAG).reverse();
+
+  // 4. For each strongly connected component C in a bottom-up order
+  //    we will also generate the canonical representation of the relations in C and replace 
+  //    the name to the relation by the hash of the canonical representation    
+
+  for (const scc of sccInOrder) {
+    const currentScc = DAGnodes[scc].scc;
+
+    // Skip SCCs that consist entirely of pre-compiled (library) rels
+    const newRels = currentScc.filter(name => !rels[name]._library);
+    if (newRels.length === 0) continue;
+
+    const convergenceStats = convergeScc(newRels, rels, options.convergence);
+    compileStats.sccs.push({
+      members: [...newRels],
+      ...convergenceStats
+    });
+
+    newRels.forEach( relName => {
+      const relDef = rels[relName];
+      const canonical = relDefToString(relDef);
+      const h = hash(canonical);
+      relAlias[relName] = h;
+    });
+
+    assignCanonicalNames(newRels, rels, relAlias);
+  }
+  
+  compileStats.sccCount = compileStats.sccs.length;
+  return { relAlias, compileStats };
+}
+
+export default { compileTypes, assignCanonicalNames };
+export { compileTypes, assignCanonicalNames };

package/convergence.mjs

@@ -0,0 +1,197 @@
+import { prettyFilter, patterns2filters } from "./pretty.mjs";
+import { getCompressed } from "./typing.mjs";
+
+export function signature(relDef) {
+  const typePatternGraph = relDef.typePatternGraph;
+  const filters = patterns2filters(typePatternGraph, ...relDef.def.patterns);
+  const result = filters.map( prettyFilter ).join("  -->  ");
+  return result;
+}
+
+export function relDefToString(relDef) {
+  const start = new Date().getTime();
+  const dumpPatterns = (rel) => {
+    switch (rel.op) {
+      case "product":
+        return [].concat(rel.patterns, ...rel.product.map(({exp}) => dumpPatterns(exp)));
+      case "union":
+        return [].concat(rel.patterns, ...rel.union.map(exp => dumpPatterns(exp)));
+      case "comp":
+        return [].concat(rel.patterns, ...rel.comp.map(exp => dumpPatterns(exp)));
+      case "ref":
+      case "identity":
+      case "dot":
+      case "div":
+      case "vid":
+      case "code":
+      case "filter":
+        return [...rel.patterns]; 
+    }
+    throw new Error("NOT EXPECTED OP:", JSON.stringify(rel, null, 2));
+  };
+  
+  const result = JSON.stringify(dumpPatterns(relDef.def).map((x) => {
+    const { pattern, fields, type} = relDef.typePatternGraph.get_pattern(x);
+    return {pattern, fields, type};
+  }));
+
+  let took = new Date().getTime() - start;
+  if (took > 200) {
+    console.log(` -- RelDefToString: size=${result.length}, took ${took} msecs`);
+  }
+  return result;
+}
+
+export function compactRel(relDef, name = "") {
+  const start = new Date().getTime();
+  const {def, typePatternGraph, varRefs } = relDef;
+
+  const {typePatternGraph : newTypePatternGraph, remapping: renumbering}  = getCompressed(typePatternGraph);
+
+  const remapRel = (rel) => {
+    rel.patterns = [renumbering[rel.patterns[0]], renumbering[rel.patterns[1]]];
+    switch (rel.op) {
+      case "product":
+        rel.product.forEach(({ exp }) => remapRel(exp));
+        break;
+      case "union":
+        rel.union.forEach(exp => remapRel(exp));
+        break;
+      case "comp":
+        rel.comp.forEach(exp => remapRel(exp));
+        break;
+      case "ref":
+      case "identity":
+      case "dot":
+      case "div":
+      case "vid":  
+      case "code":
+      case "filter":
+        break;
+      default:
+        console.error("NOT EXPECTED OP:", JSON.stringify(rel, null, 2));
+        break;
+    };
+  };
+  remapRel(def);
+  const newVarRefs = varRefs.map(x => {
+    x.inputPatternId = renumbering[x.inputPatternId];
+    x.outputPatternId = renumbering[x.outputPatternId];
+    return x;
+  });
+    
+  const time = new Date().getTime() - start;
+  if (time > 500 ) {
+    console.log(`[${new Date().getTime() - start} msecs] - COMPACTED ${name}.typePatternGraph [${typePatternGraph.size()}->${newTypePatternGraph.size()}]`);
+  }
+  return {def, typePatternGraph: newTypePatternGraph, varRefs: newVarRefs};
+}
+
+function processReference(relName, relDef, rels, varRel, index) {
+  const start = new Date().getTime();
+  let { varName } = varRel;
+  try {
+    let varRootDef = rels[varName];
+    let varInputPatternId = varRootDef.typePatternGraph.find(varRootDef.def.patterns[0]);
+    let varOutputPatternId = varRootDef.typePatternGraph.find(varRootDef.def.patterns[1]);
+    let cloned = varRootDef.typePatternGraph.clone([varInputPatternId, varOutputPatternId], relDef.typePatternGraph);
+    relDef.typePatternGraph.unify(`ref:input ${relName}(${varName})`, varRel.inputPatternId, cloned[varInputPatternId]);
+    relDef.typePatternGraph.unify("ref:output", varRel.outputPatternId, cloned[varOutputPatternId]);
+  } catch (e) {
+    e.message = `Type Error in definition of '${relName}' at call to '${varName}': lines ${varRel.start?.line}:${varRel.start?.column}...${varRel.end?.line}:${varRel.end?.column}):\n - ${e.message}`;
+    throw e;
+  }
+  const tookMs = new Date().getTime() - start;
+  if (tookMs > 200) {
+    console.log(` ---- Processing ${relName}(.., x${index}=${relDef.varRefs[index].varName}, ..) took: ${tookMs} ms`);
+  }
+}
+
+function propagateReferences(relName, relDef, rels) {
+  for (let i = 0; i < relDef.varRefs.length; i++) {
+    processReference(relName, relDef, rels, relDef.varRefs[i], i);
+  }
+}
+
+function hasSelfReference(relName, relDef) {
+  return relDef.varRefs.some(({ varName }) => varName === relName);
+}
+
+function resolveStrategy(scc, rels, options = {}) {
+  const strategy = options.strategy || "auto";
+  if (strategy !== "auto") {
+    return strategy;
+  }
+  if (scc.length === 1 && !hasSelfReference(scc[0], rels[scc[0]])) {
+    return "single_pass";
+  }
+  return "fixed_point";
+}
+
+function convergeSccSinglePass(scc, rels) {
+  const relName = scc[0];
+  const relDef = rels[relName];
+  propagateReferences(relName, relDef, rels);
+  rels[relName] = compactRel(relDef, relName);
+  return {
+    strategy: "single_pass",
+    iterations: 1,
+    converged: true
+  };
+}
+
+function convergeSccFixedPoint(scc, rels, options = {}) {
+  const maxNumberOfIterations = options.maxIterations || (2 + scc.length);
+  let converged = false;
+  let iterations = 0;
+  
+  for (let iteration = 1; iteration <= maxNumberOfIterations; iteration++) {
+    iterations = iteration;
+    let before = JSON.stringify(scc.map( relName => {
+      const relDef = rels[relName];
+      rels[relName] = compactRel(relDef,relName);
+      return signature(rels[relName]);
+    }));
+
+    let after = JSON.stringify(scc.map( relName => {
+      const relDef = compactRel(rels[relName],relName);
+      propagateReferences(relName, relDef, rels);
+      rels[relName] = compactRel(relDef,relName);
+      return signature(rels[relName]); 
+    }));
+
+    if (before === after) {
+      converged = true;
+      break;
+    }
+  }
+
+   if (!converged) {
+     const details = scc.map( relName => {
+       const relDef = rels[relName];
+       return `\x1b[94m${relName}\x1b[0m: ${signature(relDef)}`;
+     }).join('\n  ');
+     console.warn(`WARNING ⚠️  : Type derivation did NOT converge after ${maxNumberOfIterations} iterations:\n  ${details}\n  Consider adding filter expressions when defining recursive polymorphic functions.`);
+   }
+
+  return {
+    strategy: "fixed_point",
+    iterations,
+    converged
+  };
+}
+
+export function convergeScc(scc, rels, options = {}) {
+  const strategy = resolveStrategy(scc, rels, options);
+  switch (strategy) {
+    case "single_pass":
+      if (scc.length !== 1) {
+        throw new Error(`single_pass convergence requires a singleton SCC, got: ${JSON.stringify(scc)}`);
+      }
+      return convergeSccSinglePass(scc, rels);
+    case "fixed_point":
+      return convergeSccFixedPoint(scc, rels, options);
+    default:
+      throw new Error(`Unknown convergence strategy '${strategy}'`);
+  }
+}