@fraczak/k 3.0.2 → 3.1.0

package/patterns.mjs

@@ -1,601 +1,453 @@
 
-// import { prettyCode, prettyRel } from "./pretty.mjs";
+import hash from "./hash.mjs";
+import { TypePatternGraph } from "./typing.mjs";
+import { Graph, sccs, topoOrder } from "./Graph.mjs";
+import codes from "./codes.mjs";
 
+const unitCode = codes.unitCode;
 
-// Assumptions:
-// 1. Normalized code graph (i.e., codes and representatives)
-// 2. a pattern is defined by triples:
-//    { code: [null, codeId], 
-//      type: [null, product, union, vector, code], 
-//      closed: [true, false] }
+function relDefToString(relDef) {
 
-import hash from "./hash.mjs";
+  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 "vector":
+        return [].concat(rel.patterns, ...rel.vector.map(exp => dumpPatterns(exp)));
+      case "caret":
+        return [].concat(rel.patterns, dumpPatterns(rel.caret));
+      case "ref":
+      case "int":
+      case "str":
+      case "identity":
+      case "dot":
+      case "code":
+      case "pipe":  
+        return [...rel.patterns];
+    }
+    throw new Error("NOT EXPECTED OP:", rel);
+  };
 
-const unitCode = hash('$C0={};'); // it was '{}'
+  return JSON.stringify(dumpPatterns(relDef.def).map((x) => {
+    const { pattern, fields, type} = relDef.typePatternGraph.get_pattern(x);
+    return {pattern, fields, type};
+  }));
+}
 
-function patterns(codes, representatives, rels) {
-  // INPUT: 
-  //   codes: {"BG": {"code": "product", "product": {}}, ...}
-  //   representatives:{"{}": "BG", ...}
-  //   rels: {"rlz": [{op: comp,...}, ...], ...}
-  
-  // OUTPUT: returns pattern graph: 
-  //  { patternNodes: [{code,type,closed},...], 
-  //    patternEdges: {src: {label: dst, ...}}...} 
-  // as well as it will annotate rels; each rel node will have property "patterns: [i, o]"
+function compactRel(relDef, name = "") {
+  const {def, typePatternGraph, varRefs } = relDef;
+  // console.log("COMPACTING typePatternGraph of size", typePatternGraph.size());
 
-  const patternNodes = []; // e.g.: [{ code: null, type: null, closed" false}], 
-  const patternEdges = {}; // e.g.: {0: {label: 2}, ...}, 
-  
-  const codeToPattern = {}; // e.g., {"{}": 0, ...} - in order to collapse patterns resolved to the same code
+  const newTypePatternGraph = new TypePatternGraph();
+  const renumbering = typePatternGraph.cloneAll(newTypePatternGraph);
 
-  // 1 INITIALIZATION
-  // 1.1 initialize patternNodes and rels
+  newTypePatternGraph.turnSingletonPatternsIntoCodes();
 
-  function augment(rel) {
-    const i = patternNodes.length;
-    const pattern_i = { _id: i, code: null, type: null, closed: false}
-    patternNodes.push(pattern_i); 
+  const copyRel = (rel) => {
+    const newRel = {...rel, patterns:[renumbering[rel.patterns[0]], renumbering[rel.patterns[1]]]};
     switch (rel.op) {
       case "product":
-        rel["product"].forEach(({label, exp}) => augment(exp));
+        newRel.product = rel.product.map(({label, exp}) => ({label, exp: copyRel(exp)}));
         break;
       case "union":
+        newRel.union = rel.union.map(exp => copyRel(exp));
+        break;
       case "comp":
-      case "vector":
-        rel[rel.op].forEach((exp) => augment(exp));
+        newRel.comp = rel.comp.map(exp => copyRel(exp));
         break;
-      case "code":
-        rel["code"] = representatives[rel.code] || rel.code;
+      case "vector":
+        newRel.vector = rel.vector.map(exp => copyRel(exp));
         break;
       case "caret":
-        augment(rel.caret);
-        break;
-      case "filter":
-        // do nothing for now
-        console.log("filter ignored", rel);
+        newRel.caret = copyRel(rel.caret);
         break;
       case "ref":
-        // do nothing
-        break;
+      case "int":
+      case "str":
+      case "identity":
+      case "dot":
+      case "code":
       case "pipe":
         break;
-    }
-
-    const o = patternNodes.length;
-    const pattern_o = { _id: o, code: null, type: null, closed: false}
-    patternNodes.push(pattern_o);
-    rel.patterns = [i, o];
-  }
-
-  for (const relName in rels) {
-    const defs = rels[relName];
-    for (const def of defs) { augment(def); }
-  }
+      default:
+        console.error("NOT EXPECTED OP:", rel);
+        break;
+    };
+    return newRel;
+  };
+  const newDef = copyRel(def);
+  const newVarRefs = varRefs.map(x => ({
+    ...x,
+    inputPatternId: renumbering[x.inputPatternId],
+    outputPatternId: renumbering[x.outputPatternId]
+  }));;
+    
+  // console.log(`COMPACTED ${name}.typePatternGraph`, typePatternGraph.size(), '->', newTypePatternGraph.size());
+  return {def: newDef, typePatternGraph: newTypePatternGraph, varRefs: newVarRefs};
+}
 
-  // console.log(JSON.stringify(rels,"",2));
+function patterns(usedCodes, representatives, rels) {
+  codes.register(usedCodes);
+  // INPUT: 
+  //   codes: {"BG": {"code": "product", "product": {}}, ...}
+  //   representatives:{"{}": "BG", ...}
+  //   rels: {"rlz": [{op: comp,...}, ...], ...}
+ 
 
-  // 1.2 initialize 'eq' (equivalence classes over patternNodes) and 'patternEdges'
-  
-  const eq = patternNodes.map((_, i) => i); // equivalence classes over patternNodes, e.g., [0, 1, 0, ...]}
-  
-  function getRep(i) {
-    while (eq[i] !== i) { i = eq[i]; }
-    return i;
-  }
-   
-  for (const node_id in eq) { patternEdges[node_id]={}; }
-  
-  // -------- helper functions -------- 
+  // 1 INITIALIZATION
+  // 1.1 initialize patternNodes and rels
 
-  function inspect(rel) {
-    const op = rel.op;
-    // console.log(`Inspecting ${op} ${JSON.stringify(rel)}`);
+  function augment(rel, rootDef) {
     try {
-      switch (op) {
+      switch (rel.op) {
         case "product":
-          return inspectProduct(rel);
+          rel["product"].forEach(({label, exp}) => {
+            augment(exp, rootDef)
+          });
+          augmentProduct(rel,rootDef);
+          break;
         case "union":
-          return inspectUnion(rel);
-        case "comp": 
-          return inspectComp(rel);
-        case "identity":
-          return inspectIdentity(rel);
+          rel["union"].forEach((exp) => {
+            augment(exp,rootDef);
+          });
+          augmentUnion(rel,rootDef);
+          break;
+        case "comp":
+          rel["comp"].forEach((exp) => {
+            augment(exp,rootDef);
+          });
+          augmentComp(rel,rootDef);
+          break;
         case "vector":
-          return inspectVector(rel);
-        case "dot":
-          return inspectDot(rel);
-        case "code": 
-          return inspectCode(rel);
+          rel["vector"].forEach((exp) => {
+            augment(exp,rootDef);
+          });
+          augmentVector(rel,rootDef);
+          break;
+        case "code":
+          rel["code"] = representatives[rel.code] || rel.code;
+          rel.patterns = [];
+          rel.patterns[0] = rootDef.typePatternGraph.getTypeId(rel["code"]);
+          rel.patterns[1] = rel.patterns[0]; 
+          break;
+        case "caret":
+          augment(rel.caret,rootDef);
+          rel.patterns = [
+            rel.caret.patterns[0],
+            rootDef.typePatternGraph.addNewNode(
+              {pattern: '[]'}, 
+              {"vector-member": [rel.caret.patterns[1]]})
+          ];
+          break;
+        case "pipe":
+          rel.patterns = [];
+          rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+          rel.patterns[0] = rootDef.typePatternGraph.addNewNode(
+            {pattern: '[]'}, 
+            {"vector-member": [rel.patterns[1]]});
+          break;
+
         case "ref":
-          return inspectRef(rel);
+            augmentRef(rel, rootDef);
+            break;
+          //----------------
+        
         case "int":
-          return inspectInt(rel);
+          rel.patterns = [];
+          rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+          rel.patterns[1] = rootDef.typePatternGraph.getTypeId('int');
+          break;
         case "str":
-          return inspectStr(rel);
-        case "caret":
-          return inspectCaret(rel);
-        case "pipe":
-          return inspectPipe(rel);
-        case "filter":
-          return false;
+          rel.patterns = [];
+          rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+          rel.patterns[1] = rootDef.typePatternGraph.getTypeId('string');
+          break;
+        case "identity":
+          rel.patterns = [];
+          rel.patterns[0] = rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+          break;
+        case "dot":
+          rel.patterns = [];
+          rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+          rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '(...)'}, { [rel.dot]: [rel.patterns[1]] }); 
+          break;
+        
+        default:
+          console.error("NOT EXPECTED OP:", rel);
+          break;
       }
-      throw new Error(`Unknown op: ${op}`);
     } catch (e) {
-      console.error(`Code Derivation Error for '${op}' (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column}): ${e.message}.`);
+      console.error(`Code Derivation Error for '${rel.op}' (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column}): ${e.message}.`);
       throw e;
     }   
   }
-  
-  function updatePattern(pattern, {code, type, closed}) {
-    if (code) {
-      type = "code";
-      closed = true;
-      if (pattern.code == code && pattern.type == type && pattern.closed == closed) { 
-        return false; 
-      }
-      if (pattern.code) {
-        throw new Error(`Cannot update pattern with code: ${pattern.code} -> ${code}`);
-      }
-      if (pattern.type && pattern.type != codes[code]?.code) {
-        throw new Error(`Cannot update pattern with code '${code}': pattern type: ${pattern.type} -> code type: ${codes[code]?.code || 'built-in'}`);
-      }
-      pattern.code = code; 
-      pattern.closed = true;
-      pattern.type = "code";
-      return true;
-    }
-  
-    if (pattern.code) {
-      // TODO: check for potential type mismatch between 'type' and 'code.code' 
-      return false; 
-    }
-
-    let changed = false;
-  
-    if (type) {
-      if (! pattern.type) {
-        pattern.type = type;
-        changed = true;
-      } else if (pattern.type != type) {
-        throw new Error(`Cannot update pattern ${JSON.stringify(pattern)} with ${JSON.stringify({code, type, closed})}`);
-      }
-    }
-
-    if (closed && (! pattern.closed)) {
-      pattern.closed = closed;
-      return true; 
-    }
-      
-    return changed;    
-  }
-  
-  function join(i, j) {
-    const iRep = getRep(i);
-    const jRep = getRep(j);
-    if (iRep == jRep) { return false; } 
-    // create new representative
-    const iPattern = patternNodes[iRep];
-    const jPattern = patternNodes[jRep];
-
-    const newRep = patternNodes.length;
-    const newPattern = { 
-      _id: newRep, 
-      code: null, type: null, closed: false, 
-      _from: `(${iPattern._from || iRep},${jPattern._from || jRep})`};
-    patternNodes[newRep] = newPattern;
-    patternEdges[newRep] = {};
-    eq[iRep] = eq[jRep] = eq[newRep] = newRep;   
-    // we still have to merge patterns and migrate edges
-    updatePattern(newPattern, iPattern);
-    updatePattern(newPattern, jPattern);
-    migrateEdges(jRep, newRep);
-    migrateEdges(iRep, newRep);
-    
-    return newRep;  
-  }
-  
-  function migrateEdges(from_i, to_j) {
-    const iEdges = patternEdges[from_i];
-    const jEdges = patternEdges[to_j];
-    for (const label in iEdges) {
-      const iTarget = iEdges[label];
-      const jTarget = jEdges[label];
-      if (jTarget) {
-        const newTarget = join(iTarget, jTarget);
-        if (newTarget) {
-          jEdges[label] = newTarget;
-        }
-      } else {
-        jEdges[label] = iTarget;
-      }
-    }
-  }
-  
-  function addEdge(src, label, target) {
-    // console.log("addEdge", src, label, target, "old target", patternEdges[src][label] || "none");
-    const srcPattern = patternNodes[getRep(src)];
-    if (srcPattern.type == "code") {
-      const code = codes[representatives[srcPattern.code] || srcPattern.code];
-      if (code.code == "product" || code.code == "union" ) {
-        return updatePattern(patternNodes[getRep(target)], {code: code[code.code][label]})
-      }  
-      throw new Error(`Cannot add edge ${label} to code ${JSON.stringify(code)}`);
-    }
-    if (srcPattern.type == 'vector') {
-      if (/^(0|[1-9][0-9]*)$/.test(label)) {
-        const old_target = patternEdges[src]['vector-member'];
-        if (old_target) {
-          const newTarget = join(old_target, target);
-          if (newTarget) {
-            patternEdges[src][label] = newTarget;
-            return true;
-          }
-          return false;
-        }
-        patternEdges[src]['vector-member'] = target;
-        return true;
-      }
-      throw new Error(`Cannot add edge ${label} to code ${JSON.stringify(code)}`);
-    }
-    const old_target = patternEdges[src][label];
-    if (old_target) {
-      const newTarget = join(old_target, target);
-      if (newTarget) {
-        patternEdges[src][label] = newTarget;
-        return true;
-      }
-      return false;
-    }
-    
-    if (srcPattern.closed) {
-      throw new Error(`Cannot add edge ${label} to pattern ${JSON.stringify(srcPattern)}`);
-    }
-    patternEdges[src][label] = target;
-    return true;
-  }
-
-  function inspectInt(rel) {
-    const o_pattern = patternNodes[rel.patterns[1]];
-    return updatePattern(o_pattern, {code: "int", type: "code", closed: true});
-  }
-  
-  function inspectStr(rel) {
-    const o_pattern = patternNodes[rel.patterns[1]];
-    return updatePattern(o_pattern, {code: "string", type: "code", closed: true});
-  }
-
-  function inspectPipe(rel) {
-    const old_i = getRep(rel.patterns[0]);
-    const old_o = getRep(rel.patterns[1]);
-    const old_i_pattern = patternNodes[old_i];
-  
-    let modified = updatePattern(old_i_pattern, {type: "vector", closed: true});
-     
-    let member_i = patternEdges[old_i]["vector-member"];
-    if (member_i == undefined ) { 
-      modified = true;
-      member_i = patternNodes.length;
-      patternNodes.push({ _id: member_i, code: null, type: null, closed: false})
-      patternEdges[old_i]["vector-member"] = member_i;
-      eq[member_i] = member_i;
-    }
-    member_i =  getRep(member_i);
-    modified = join(member_i, old_o) || modified;
-    console.log([old_i,old_o,member_i].map( x => [x,patternNodes[x]]));
-    return modified;
-  }
-
-  function inspectCaret(rel) {
-    let modified  = join(rel.patterns[0], rel.caret.patterns[0]);
-    const old_o = getRep(rel.patterns[1]);
-    const old_o_pattern = patternNodes[old_o];
-  
-    modified = updatePattern(old_o_pattern, {type: "vector", closed: true});
-     
-    let member_o = patternEdges[old_o]["vector-member"];
-    if (member_o == undefined ) {
-      modified = true;
-      member_o = patternNodes.length;
-      patternNodes.push({ _id: member_o, code: null, type: null, closed: false})
-      patternEdges[old_o]["vector-member"] = member_o;
-      eq[member_o] = member_o;
-    }
-    member_o =  getRep(member_o);
-    modified = join(rel.caret.patterns[1], member_o) || modified;
-    return modified;
-  }
 
-
-  function inspectDot(rel) {
-    const old_i = getRep(rel.patterns[0]);
-    const old_o = getRep(rel.patterns[1]);
-    const old_i_pattern = patternNodes[old_i];
-    const old_o_pattern = patternNodes[old_o];
-    const field = rel.dot;
-    if (old_i_pattern.type == "code") {
-      if (old_i_pattern.code == "int" || old_i_pattern.code == "bool" || old_i_pattern.code == "string") {
-        return updatePattern(old_o_pattern, {code: "product", type: "code", closed: true, product: []});
-      }
-      const code = codes[representatives[old_i_pattern.code] || old_i_pattern.code];
-      if (code.code == "product" || code.code == "union" || code.code == "vector") {
-        const target_code = code[code.code][field];
-        if (target_code) 
-          return updatePattern(old_o_pattern, {code: target_code});
-      }
-      throw new Error(`Cannot find field ${field} in code ${JSON.stringify(code)}`); 
-    }
-
-    return addEdge(old_i, field, old_o);
-  }
-  
-  function inspectProduct(rel) {
+  function augmentProduct(rel,rootDef) {
+    rel.patterns = [];
     switch (rel.product.length) {
-      case 0: {
-        // unit
-        const old_o = getRep(rel.patterns[1]);
-        const old_o_pattern = patternNodes[old_o];
-        // check that there is no patternEdge from old_o
-        for (const label in patternEdges[old_o]) {
-          throw new Error(`Label ${label} in code '{}'.`);
-        }
-        return updatePattern(old_o_pattern, {code: unitCode, type: "code", closed: true});
-      }
-      case 1: {
-        // union constructor:  %old_i { %exp_i exp %exp_o field } %old_o 
-        const field = rel.product[0].label;
-        const exp = rel.product[0].exp;
-        var modified = inspect(exp);
-  
-        const old_i = getRep(rel.patterns[0]);
-        const old_o = getRep(rel.patterns[1]);
-        const old_o_pattern = patternNodes[old_o];
-        
-        const exp_i = getRep(exp.patterns[0]);
-        const exp_o = getRep(exp.patterns[1]);
+      case 0: 
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId(unitCode);
+        break;
+      case 1:
+        // union/variant constructor:  %old_i { %exp_i exp %exp_o field } %old_o 
+        rel.patterns[0] = rel.product[0].exp.patterns[0];
+        rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '<...>'}, 
+          {[rel.product[0].label]: [rel.product[0].exp.patterns[1]]});
+        break;
+      default:
+        // product constructor %old_i { %exp0_i exp0 %exp0_o field0, ... %expk_i expk %expk_o fieldk } %old_o
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rootDef.typePatternGraph.unify(
+          "product:input",
+          rel.patterns[0], 
+          ...rel.product.map(({exp}) => exp.patterns[0]));
         
-        var modified = join(exp_i, old_i);
-  
-        modified = updatePattern(old_o_pattern, {code: null, type: "union", closed: false}) || modified;
-        modified = addEdge(old_o, field, exp_o) || modified;
-  
-        return modified;
-      }
-    }
-    // product constructor %old_i { %exp0_i exp0 %exp0_o field0, ... %expk_i expk %expk_o fieldk } %old_o
-    var modified = rel.product.reduce((modified, {label,exp}) => 
-      inspect(exp) || modified, false);
-  
-    const fields = rel.product.map(({label, exp}) => 
-      ({label, exp_i: getRep(exp.patterns[0]), exp_o: getRep(exp.patterns[1])}));
-  
-    const old_i = getRep(rel.patterns[0]);
-    const old_o = getRep(rel.patterns[1]);
-    const old_o_pattern = patternNodes[old_o];
-    
-    for (const {label, exp_i, exp_o} of fields) {
-      modified = join(exp_i, old_i) || modified;
-      modified = addEdge(old_o, label, exp_o) || modified;
-    }
-    modified = updatePattern(old_o_pattern, {type: "product", closed: true}) || modified;
-    // check that patternEdges coincide with field labels
-    const patternEdgeLabels = Object.keys(patternEdges[old_o]);
-    const labels = fields.reduce( (labels,{label}) => 
-      ({[label]: true, ...labels}), {});
-   
-    for (const label of patternEdgeLabels) {
-      if (!labels[label]) {
-        throw new Error(`Label '${label}' not allowed for pattern ${JSON.stringify({...old_o_pattern, fields})}`);
-      }
-    }
-    return modified;
+        rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '{}'},
+          rel.product.reduce((edges, {label, exp}) => {
+            edges[label] = [exp.patterns[1]];
+            return edges;
+          }, {})
+        );
+    };
   }
   
-  function inspectUnion(rel) {
-  
-    const old_o = getRep(rel.patterns[1]);
+  function augmentUnion(rel,rootDef) {
+    rel.patterns = [];
     if (rel.union.length == 0) {
-      return updatePattern(patternNodes[old_o], {type: "union", closed: true}); 
+      rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+      rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '<>'}); 
+    } else {
+      rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+      rootDef.typePatternGraph.unify(
+        "union:input",
+        rel.patterns[0],
+        ...rel.union.map(exp => exp.patterns[0]));
+      
+      rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+      rootDef.typePatternGraph.unify(
+        "union:output",
+        rel.patterns[1],
+        ...rel.union.map(exp => exp.patterns[1]));
     }
-    // union: %old_i < %exp0_i exp0 %exp0_o, ... %expk_i expk %expk_o > %old_o
-    
-    const modified = rel.union.reduce((modified, exp) => {
-      var new_modified = inspect(exp) || modified;
-      new_modified = join(rel.patterns[0], exp.patterns[0]) || modified;
-      new_modified = join(rel.patterns[1], exp.patterns[1]) || modified;
-      return new_modified;
-    }, false);
-    return modified;
   }
 
-  function inspectComp(rel) {
-    if (rel.comp.length == 0) { return inspectIdentity(rel); }
-
-    // comp: %old_i ( %exp0_i exp0 %exp0_o, ... %expk_i expk %expk_o ) %old_o
-    const old_i = getRep(rel.patterns[0]);
-    const [modified,pattern_o] = rel.comp.reduce(([modified,pattern_i], exp) => {
-      var new_modified = inspect(exp) || modified;
-      new_modified = join(pattern_i, exp.patterns[0]) || modified;
-      return [new_modified, exp.patterns[1]];
-    }, [false, old_i]);
-    return join(pattern_o, rel.patterns[1]) || modified;
-  }
-  
-  function inspectIdentity(rel) { 
-    return join(rel.patterns[0], rel.patterns[1]);
-  }
-  
-  function inspectVector(rel) { 
-    const old_o = getRep(rel.patterns[1]);
-    var modified = updatePattern(patternNodes[old_o], {type: "vector", closed: true});
-    if (rel.vector.length == 0) {
-      return modified; 
-    }
-    // vector: %old_i [ %exp0_i exp0 %exp0_o, ... %expk_i expk %expk_o] %old_o
-    
-    let member_o = patternEdges[old_o]["vector-member"];
-    if (member_o) { 
-      member_o =  getRep(patternEdges[old_o]["vector-member"]);
+  function augmentComp(rel,rootDef) {
+    rel.patterns = [];
+    if (rel.comp.length == 0) { 
+      rel.patterns[0] = rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
     } else {
-      modified = true;
-      member_o = patternNodes.length;
-      patternNodes.push({ _id: member_o, code: null, type: null, closed: false})
-      patternEdges[old_o]["vector-member"] = member_o;
-      eq[member_o] = member_o;
-    }
 
-    modified = rel.vector.reduce((modified, exp) => {
-      modified = inspect(exp) || modified;
-      modified = join(rel.patterns[0], exp.patterns[0]) || modified;
-      modified = join(member_o, exp.patterns[1]) || modified;
-      return modified;
-    }, modified);
-    return modified;
-  }
-  
-  function inspectCode(rel) {
-    const old_i = getRep(rel.patterns[0]);
-    var modified = updatePattern(patternNodes[old_i], {code: representatives[rel.code] || rel.code});
-    return join(old_i, rel.patterns[1]) || modified;
-  }
-  
-  function inspectRef(rel) { 
-    const relDefs = rels[rel.ref];
-    if (!relDefs) {
-      switch (rel.ref) {
-        case "_log!":
-          return inspectIdentity(rel);
-        case "true": 
-        case "false": return updatePattern(patternNodes[rel.patterns[1]], {code: "bool"});
-
-        case "PLUS":
-        case "TIMES": 
-          // should add updating the input parrent to code `$[int]`
-          // console.log("PLUS/TIMES", rel);
-          return updatePattern(patternNodes[rel.patterns[1]], {code: "int"});
-        case "CONCAT":
-          return updatePattern(patternNodes[rel.patterns[1]], {code: "string"});
-        case "toDateMsec":
-          return updatePattern(patternNodes[rel.patterns[1]], {code: "int"});
-        case "toJSON":
-          return updatePattern(patternNodes[rel.patterns[1]], {code: "string"});
-        case "toDateStr":
-          return updatePattern(patternNodes[rel.patterns[1]], {code: "string"});
-
-        // TO DO
-        case "GT":
-        case "EQ":
-        case "null":
-        case "DIV":
-        case "FDIV":
-        case "fromJSON":
-        case "CONS":
-        case "SNOC":
-          return false;
-      }
-      throw new Error(`No definition found for ${rel.ref}`);  
-    }
-    // For now we assume only the first def which does not throw!!!!
-    // That's good enough if all defs are typed by different input codes.
-    for (const def of relDefs) {
-      try {
-        // var modified = join(def.patterns[0], rel.patterns[0]);
-        var modified = updatePattern(
-          patternNodes[getRep(rel.patterns[0])], 
-          patternNodes[getRep(def.patterns[0])]
+      for (let i = 0; i < rel.comp.length - 1; i++) {
+        rootDef.typePatternGraph.unify(
+          "comp:chain",
+          rel.comp[i].patterns[1],
+          rel.comp[i+1].patterns[0]
         );
-
-        // modified = join(def.patterns[1], rel.patterns[1]) || modified;
-        modified = updatePattern(
-          patternNodes[getRep(rel.patterns[1])], 
-          patternNodes[getRep(def.patterns[1])]
-        ) || modified;
-
-        return modified;
-      } catch (e) {}
-    } 
-    throw new Error(`No matching definition found for ${rel.ref}`);  
-  }
-
-
-  // --------- main loop --------------
-
-  // 2. loop until no more changes
-
-  let changed = true;
-  while (changed) { 
-    changed = false;
-    for (const relName in rels) {
-      const defs = rels[relName];
-      for (const def of defs) {
-        changed = inspect(def) || changed;
       }
+
+      rel.patterns[0] = rel.comp[0].patterns[0];  
+      rel.patterns[1] = rel.comp[rel.comp.length - 1].patterns[1];
     }
   }
 
-  // 3. compress the pattern graph
-
-  // 3.1. get representative nodes for each pattern
-  // pNode = {repFromPatternNodes: 0, repFromPatternNodes: 1, ...}
-  const pNodes = {};
-  eq.map(getRep).forEach((p) => {
-    pNodes[p] = p;
-  });
-  Object.keys(pNodes).map((p,i) => pNodes[p] = i);
+  function augmentVector(rel,rootDef) {
+    rel.patterns = []; 
+    rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+    rootDef.typePatternGraph.unify(
+      "vector:input",
+      rel.patterns[0],
+      ...rel.vector.map(exp => exp.patterns[0]));
+      
+    let member = rootDef.typePatternGraph.addNewNode();
+    rootDef.typePatternGraph.unify(
+      "vector:output",
+      member,
+      ...rel.vector.map(exp => exp.patterns[1])
+    );
+    rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [member]});
+  }
 
-  function updatePatterns(rel) {
-    rel.patterns[0] = pNodes[getRep(rel.patterns[0])];
-    rel.patterns[1] = pNodes[getRep(rel.patterns[1])];
-    switch (rel.op) {
-      case "product":
-        rel["product"].forEach(({label, exp}) => updatePatterns(exp));
+  function augmentRef(rel,rootDef) { 
+    rel.patterns = [];
+    if (rel.ref in rels) {
+      rel.patterns = [rootDef.typePatternGraph.addNewNode(), rootDef.typePatternGraph.addNewNode()];
+      rootDef.varRefs.push( {
+          varName: rel.ref, 
+          inputPatternId: rel.patterns[0], 
+          outputPatternId: rel.patterns[1],
+          start: rel.start,
+          end: rel.end
+        });
+      return;
+    }
+    // it is built-in
+    switch (rel.ref) {
+      case "_log!":
+        rel.patterns[0] = rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
         break;
-      case "union":
-      case "comp":
-      case "vector":
-        rel[rel.op].forEach((exp) => updatePatterns(exp));
+      case "true": 
+      case "false":
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId('bool');
+        break;
+      case "PLUS":
+      case "TIMES": 
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId('int');
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [rel.patterns[1]]});
+        break;
+      case "CONCAT":
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId('string');
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [rel.patterns[1]]});
+        break;
+      case "toVEC":
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [rel.patterns[0]]});
+        break;
+      case "toDateMsec":
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId('int');
+        break;
+      case "toJSON":
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId('string');
+        break;
+      case "toDateStr":
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.getTypeId('string');
+        break;
+      case "GT":
+      case "EQ":  
+        rel.patterns[0] = rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [rootDef.typePatternGraph.addNewNode()]});
+        break;
+      case "fromJSON":
+        rel.patterns[0] = rootDef.typePatternGraph.getTypeId('string');
+        rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+        break;
+      case "CONS": {
+          let member = rootDef.typePatternGraph.addNewNode();
+          rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [member]});
+          rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '{}'}, {"car": [member], "cdr": [rel.patterns[1]]});
+        }; break;
+      case "SNOC": {
+          let member = rootDef.typePatternGraph.addNewNode();
+          rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [member]});
+          rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '{}'}, {"car": [member], "cdr": [rel.patterns[0]]});
+        }; break;
+      // TO DO
+      case "null":
+      case "DIV":
+      case "FDIV":
+        rel.patterns = [rootDef.typePatternGraph.addNewNode(), rootDef.typePatternGraph.addNewNode()];
+        break;
+      default:
+        throw new Error(`No definition found for ${rel.ref}`);  
     }
-  }
+  }  
 
-  for (const relName in rels) {
-    const defs = rels[relName];
-    for (const def of defs) { updatePatterns(def); }
-  }
+  // ==================================================================================
+  // ----------------------------------------------------------------------------------
+  // 1. Initialize the typePatternGraph and varRefs for each relation
 
-  const newPatternNodes = [];
-  for (const i in pNodes) {
-    newPatternNodes[pNodes[i]] = patternNodes[i];
+  for (const relName in rels) {
+    const rootDef = rels[relName];
+    rootDef.typePatternGraph = new TypePatternGraph();
+    rootDef.varRefs = []; // the list of non-built references as pointers to AST nodes
+    augment(rootDef.def, rootDef);
   }
-  const newPatternEdges = Object.keys(patternEdges).reduce(function (newPatternEdges, src) {
-    const newSrc = pNodes[src];
-    if (newSrc != undefined) { 
-      newPatternEdges[newSrc] = Object.keys(patternEdges[src]).reduce(function (newPatternEdges, label) {
-        newPatternEdges[label] = pNodes[getRep(patternEdges[src][label])];
-        return newPatternEdges;
-      }, {});
-    }
-    return newPatternEdges;
-  }, {});
+   
+  
+  // 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);
+
+  // 4. For each strongly connected component C in a bottom-up order
+
+  for (const scc of sccInOrder.reverse()) {
+    // console.log(`SCC: { ${DAGnodes[scc].scc} }`);
+
+    const maxNumberOfIterations = 10;
+    
+    for (let iteration = 1; iteration <= maxNumberOfIterations; iteration++) {
+      
+      // console.log(`>>>>>> Iteration ${iteration}  for SCC: { ${DAGnodes[scc].scc} }`);
+      //    4.1 For every r in C, compute the new typePatternGraph of r, i.e.:
+
+      let before = JSON.stringify(DAGnodes[scc].scc.map( relName => {
+        const relDef = rels[relName];
+        // console.log("-----------------------------------");
+        // console.log(relDefToString(relDef));
+        rels[relName] = compactRel(relDef,relName);
+        // console.log(relDefToString(rels[relName]));
+        return relDefToString(rels[relName]);
+      }));
+    
+      let after = JSON.stringify(DAGnodes[scc].scc.map( relName => {
+        const relDef = compactRel(rels[relName],relName);
+        for (let i = 0; i < relDef.varRefs.length; i++) {
+          // console.log(` ####### Processing ${relName}(..x${i}=${relDef.varRefs[i].varName}..)`);
+          let varRel = relDef.varRefs[i];
+          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) {
+            console.error(`Type Error in call to ${varName} in definition of ${relName}: lines ${varRel.start?.line}:${varRel.start?.column}...${varRel.end?.line}:${varRel.end?.column}): ${e.message}.`);       
+            throw e;
+          }
+        }
 
-  // loops in the pattern graph are forcing the pattern to be union!
+        rels[relName] = compactRel(relDef,relName);
+        
+        return relDefToString(rels[relName]); 
+      }));
 
-  for( const i in newPatternNodes) {
-    const node = newPatternNodes[i];
-    for (const label in newPatternEdges[i]) {
-      if (newPatternEdges[i][label] == i) {
-        if (node.type == "product") {
-          throw new Error("Loop in product code!");
-        }
-        node.type = "union";
+      if (before == after) {
+        // console.log("SUCCESS!");
+        break;
       }
-    }
+    } // while
+      
   }
-
-  return { patternNodes: newPatternNodes, patternEdges: newPatternEdges };  
 }
 
-
-
 export default { patterns };
 export { patterns };