@fraczak/k 5.1.2 → 6.0.1

package/TypeGraph.mjs

@@ -0,0 +1,43 @@
+export class TypePatternForest {
+  constructor() {
+    this.nodes = [];
+    this.parent = [];
+  }
+
+  // Find the root of the set containing `x`
+  find(x) {
+    if (this.nodes[x] == undefined) 
+      throw new Error(`Node of id='${x}' not found in the forest`);
+    let result = x;
+    let parent = this.parent[result];
+    while (parent != undefined) {
+      parent = this.parent[result = parent];
+      if (parent == result) {
+        console.log("Can happen a loop in the forest? It shouldn't!");
+        break;
+      }
+        
+    }
+    return result;
+  }
+
+  addChildren(parentId, childrenIds) {
+    const parent = this.find(parentId);
+    childrenIds.forEach(childId => {
+      const child = this.find(childId);
+      if (this.nodes[child].pattern != 'type')
+        this.parent[child] = parent;
+    });
+  }
+
+  addNewNode(flatTypePattern, children = []) {
+    const that = this;
+    const id = this.nodes.length;
+    // const node = {...flatTypePattern, _id: id};
+    const node = {...flatTypePattern}
+    that.nodes.push(node);
+    Array.from(new Set(children.map(that.find.bind(that))))
+    .forEach(rep => {that.parent[rep] = id});
+    return id;
+  }
+}

package/TypePatternGraph.mjs

@@ -0,0 +1,251 @@
+import { Graph } from "./Graph.mjs";
+import { unify_two_patterns } from "./unification.mjs";
+import { TypePatternForest } from "./TypeGraph.mjs";
+
+function asSet(vector) { 
+  return Array.from(new Set(vector));
+}
+
+const matchAllPattern = {pattern: '(...)', fields: []};
+/*
+$Pattern = < 
+  string code, 
+  open? product, 
+  open? union, 
+  open? unknown
+>;
+$open? = < {} open, {} closed >;
+
+we use the string notation: 
+'(...)' | '{...}' | '<...>' | '{}' | '<>' | 'type'
+e.g.:
+{pattern: '<...>'}
+{pattern: 'type', type: code_name}
+*/
+
+function assertValidPatternNode(pattern, fields = {}) {
+  if (pattern.pattern == '()') {
+    throw new Error("Closed unknown pattern '()' is not supported.");
+  }
+  if (pattern.pattern == '(...)' && Object.keys(fields).length !== 0) {
+    throw new Error("Unknown-kind pattern '(...)' cannot have fields.");
+  }
+}
+
+class TypePatternGraph {
+  constructor(registerCodeDef, findCode) {
+    this.patterns = new TypePatternForest();
+    this.edges = []; // an edge at index i is a map {lab: asMapSet([i1,...]), ...}
+                     // representing `patterns.node[i] --[lab]--> {i1:i1,...}, ...
+    this.codeId = { }; // type-name -> index
+    this.registerCodeDef = registerCodeDef;
+    this.findCode = findCode;
+  }
+
+  turnSingletonPatternsIntoCodes() {
+    const singletonPatterns = this.findSingletonPatterns();
+    const newCodeDefs= {}
+    for(const patternId of singletonPatterns) {
+      const pattern = this.get_pattern(patternId);
+      switch (pattern.pattern) {
+        case '<>': 
+        case '{}': {
+          const code = (pattern.pattern == '<>') ? 'union' : 'product';
+          const fieldsWithDest = this.edges[patternId];
+          newCodeDefs[`-${patternId}-`] = {
+            code: code,
+            [code]: Object.keys(fieldsWithDest).reduce((fields, lab) => {
+              const auxDests = Object.values(fieldsWithDest[lab]).map(id => this.find(id));
+              const destAsMapSet = auxDests.reduce( (mapSet, x) => ({...mapSet, [JSON.stringify(x)]: x}), {});
+              const dests = Object.values(destAsMapSet);
+              if (dests.length != 1) {
+                throw new Error(`Expected one destination for ${lab} in ${patternId}`); 
+              }
+              const destPattern = this.get_pattern(dests[0]);
+              fields[lab] = (destPattern.pattern == 'type') ? destPattern.type : `-${dests[0]}-`;
+              return fields;
+            }, {})
+          }; 
+        }; break;
+        
+        default: 
+          throw new Error(`Unexpected pattern ${JSON.stringify(pattern)}`);
+      }
+    } 
+    //        - add them all to 'codes'
+    const representatives  = this.registerCodeDef(newCodeDefs);
+
+    for( const id of singletonPatterns) {
+      this.unify('singleton', id, this.getTypeId(representatives[`-${id}-`]));
+    }
+  }
+
+
+  get_pattern(id) {
+    return this.patterns.nodes[this.find(id)];
+  }
+
+  find(id) {
+    return this.patterns.find(id);
+  }
+
+  findSingletonPatterns() {
+    const gNodes = this.patterns.nodes.map((x,i) => i).filter(x => this.patterns.parent[x] == undefined);
+    const gEdges = [].concat(
+      ...gNodes.map(x => 
+        [].concat( 
+          ...Object.values(this.edges[x]).map( asMap =>
+            [].concat(...Object.values(asMap).map(y => 
+              ({src: x, dst: this.find(y)}))
+            )
+          )
+        )
+      )
+    );
+
+    const gEdgesWithoutParrallelEdges  = Array.from(new Set(gEdges));
+    const gGraph = new Graph(gEdgesWithoutParrallelEdges);
+    const queue = gNodes.filter(x => 
+      this.patterns.nodes[x].pattern in {'(...)':1,'{...}':1, '<...>':1});
+    const excludedSet = new Set(queue);
+
+    while (queue.length > 0) {
+      const x = queue.pop();
+      for (const e of gGraph.dst[x] || []) {
+        const y = gGraph.edges[e].src;
+        if (excludedSet.has(y)) continue;
+        excludedSet.add(y);
+        queue.push(y);
+      }
+    }
+
+    return gNodes.filter(x => !((excludedSet.has(x)) || (this.patterns.nodes[x].pattern == 'type')));
+  }
+
+  clone(roots,targetGraph = this) { 
+    const result = {}; // mapping from original ids to cloned ids
+    const find = (x) => this.find(x);
+    let ids = [...roots];
+    while (ids.length > 0) {
+      const old_id = ids.pop();
+      const i = find(old_id);
+      if (i in result) {
+        result[old_id] = result[i];
+        continue;
+      }
+      const cloned = (pattern => {
+        if (pattern.pattern == 'type') return targetGraph.getTypeId(pattern.type);
+        return targetGraph.patterns.addNewNode(pattern);
+      })(this.patterns.nodes[i]);
+      result[i] = cloned;
+      result[old_id] = cloned;
+      if (this.patterns.nodes[i].pattern == 'type') 
+        continue;
+      const edges = this.edges[i];
+      for (const lab in edges) {
+        ids = ids.concat(Object.values(edges[lab]));
+      }
+    }
+    for (const i in result) {
+      if (i != find(i)) continue;
+      if (this.patterns.nodes[i].pattern == 'type') 
+        continue;
+      const edges = this.edges[i];
+      const new_id = result[i];
+      targetGraph.edges[new_id] = {};
+      for (const lab in edges) {
+        targetGraph.edges[new_id][lab] = asSet(edges[lab].map(x => result[find(x)]));
+      }
+    }
+    return result;
+  }
+
+  cloneAll(targetGraph = this) {
+    return this.clone(this.patterns.nodes.map((x,i) => i), targetGraph);
+  }
+
+  unify_patterns(...patterns) {  
+    const unifyFn = unify_two_patterns.bind(null, this.findCode);
+    return patterns.reduce(unifyFn, {pattern: '(...)', fields: []});
+  }
+
+  unify(rule, ...ids) {
+    const find = (x) => this.find(x);
+    const reps = Array.from(new Set(ids.map(find))); 
+    if (reps.length < 2) return false;
+    const rep_patters = reps.map(x => {
+      const pattern = this.get_pattern(x);
+      const fields = Object.keys(this.edges[x] || {});
+      return {...pattern, fields: fields};
+    });
+
+    const new_pattern = (() => { try {
+      return {...this.unify_patterns(...rep_patters), rule : rule}
+    } catch (e) {
+      e.message = `Unification rule "${rule}"\n - ${e.message}`;
+      throw e;
+    } })();
+    const new_id = (() => {
+      if (new_pattern.pattern == 'type') {
+        const id = this.getTypeId(new_pattern.type);
+        this.patterns.addChildren(id, reps);
+        return id;
+      };
+      return this.patterns.addNewNode(new_pattern, reps);
+    })();
+    // console.log("    * new ", JSON.stringify({new_id, new_pattern}));
+    // console.log("          ", JSON.stringify(rep_patters));
+    this.edges[new_id] = this.edges[new_id] || {};
+
+    for (const i of reps) {
+      const edges = this.edges[i];
+      for (const lab in edges) {
+        const dests = asSet(edges[lab].map(find));
+        this.edges[new_id][lab] = asSet([...(this.edges[new_id][lab] || []), ...dests]);
+      }
+    }
+    
+    for ( const lab of Object.keys(this.edges[new_id]) ) {
+      this.unify(rule+'.', ...this.edges[new_id][lab]);      
+    }
+
+    return true;
+  }
+
+  addNewNode(pattern = matchAllPattern, fields = {}) {
+    assertValidPatternNode(pattern, fields);
+    const id = this.patterns.addNewNode(pattern);
+    const find = (x) => this.patterns.find(x);
+    this.edges[id] = {};
+    for (const [lab,dest] of Object.entries(fields)) {
+      this.edges[id][lab] = asSet(dest.map(find));
+    }
+    return id;
+  }
+
+  getTypeId(type) {
+    if (type == undefined) throw new Error("code name cannot be 'undefined'! "); //TODO: remove after testing
+    if ( this.codeId[type] == undefined ) {
+      const code = this.findCode(type);
+      if (code == undefined)
+        throw new Error(`Type '${type}' is not defined in codes.`);
+      const typeId = this.patterns.addNewNode({pattern: 'type', type: type});
+      this.codeId[type] = typeId
+      this.edges[typeId] = {};
+      for ( const [lab, destType] of Object.entries(code[code.code]) ) {
+        const destTypeId = this.getTypeId(destType);
+        this.edges[typeId][lab] = asSet([destTypeId]);
+      }
+    }
+    return this.codeId[type];
+
+  }
+
+  size() {
+    const typeNodes = this.patterns.nodes.filter(x => x.pattern == 'type').length;
+    return [this.patterns.nodes.length,typeNodes];
+  }
+}
+
+export { TypePatternGraph };
+export default { TypePatternGraph };

package/Value.mjs

@@ -0,0 +1,192 @@
+
+// const nameRE = /^[a-zA-Z0-9_][a-zA-Z0-9_?!]*$/;
+const nameRE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
+
+function pLabel(label) {
+  return nameRE.test(label) ? `${label}` : `${JSON.stringify(label)}`;
+}
+const getFields = obj => {
+  if (!obj || typeof obj !== 'object' || Array.isArray(obj)) {
+    throw new Error("Not a map!");
+  }
+  return Object.keys(obj);
+};
+
+function fromObject(obj) {
+  const fields = getFields(obj);
+  if (fields.length === 1) {
+    const field = fields[0];
+    return new Variant(field, fromObject(obj[field]));
+  } 
+  return new Product(
+    fields.reduce( (result, field) => {
+      result[field] = fromObject(obj[field]);
+      return result;
+    }, {})
+  );
+};
+
+class Value {
+  constructor(type, pattern = null) {
+    this.type = type;
+    this.pattern = pattern;
+  }
+  toString() {
+    return `${this.constructor.name}(type: ${this.type})`;
+  }
+  toJSON() {
+    return { type: this.type };
+  }
+}
+
+function toVector(m) {
+  let vector = [];
+  for (let i = 0; i < Object.keys(m).length; i++) {
+    if (m[i] === undefined) {
+      vector = [];
+      break;
+    }
+    vector.push(m[i]);
+  }
+  return vector;
+}
+
+function cloneSubpattern(pattern, root = 0) {
+  if (!pattern || pattern.length === 0) return null;
+  const visited = new Map();
+  const nodes = [];
+
+  function visit(nodeId) {
+    if (visited.has(nodeId)) return visited.get(nodeId);
+    const newId = nodes.length;
+    visited.set(nodeId, newId);
+    const [kind, edges] = pattern[nodeId];
+    nodes.push([kind, []]);
+    nodes[newId][1] = edges.map(([label, target]) => [label, visit(target)]);
+    return newId;
+  }
+
+  visit(root);
+  return nodes;
+}
+
+function edgeSubpattern(pattern, label) {
+  if (!pattern || pattern.length === 0) return null;
+  const [, edges] = pattern[0];
+  const edge = edges.find(([edgeLabel]) => edgeLabel === label);
+  if (!edge) return null;
+  return cloneSubpattern(pattern, edge[1]);
+}
+
+function composePattern(kind, entries) {
+  if (entries.some(([, childPattern]) => !childPattern)) return null;
+  const result = [[kind, []]];
+
+  for (const [label, childPattern] of entries) {
+    const offset = result.length;
+    result[0][1].push([label, offset]);
+    for (const [childKind, childEdges] of childPattern) {
+      result.push([
+        childKind,
+        childEdges.map(([edgeLabel, target]) => [edgeLabel, target + offset])
+      ]);
+    }
+  }
+
+  return result;
+}
+
+function mergePatterns(declared, observed) {
+  if (!declared || declared.length === 0) return observed;
+  if (!observed || observed.length === 0) return declared;
+  const nodes = [];
+  const cloneMemo = new Map();
+  const mergeMemo = new Map();
+
+  function cloneInto(sourceTag, pattern, nodeId) {
+    const key = `${sourceTag}:${nodeId}`;
+    if (cloneMemo.has(key)) return cloneMemo.get(key);
+    const newId = nodes.length;
+    cloneMemo.set(key, newId);
+    const [kind, edges] = pattern[nodeId];
+    nodes.push([kind, []]);
+    nodes[newId][1] = edges.map(([label, target]) => [label, cloneInto(sourceTag, pattern, target)]);
+    return newId;
+  }
+
+  function visit(declaredId, observedId) {
+    if (declaredId == null) return cloneInto("o", observed, observedId);
+    if (observedId == null) return cloneInto("d", declared, declaredId);
+
+    const key = `${declaredId}|${observedId}`;
+    if (mergeMemo.has(key)) return mergeMemo.get(key);
+
+    const [declaredKind, declaredEdges] = declared[declaredId];
+    const [observedKind, observedEdges] = observed[observedId];
+
+    if (declaredKind === "any") return cloneInto("o", observed, observedId);
+    if (observedKind === "any") return cloneInto("d", declared, declaredId);
+    if (declaredKind !== observedKind) return cloneInto("d", declared, declaredId);
+
+    const newId = nodes.length;
+    mergeMemo.set(key, newId);
+    nodes.push([declaredKind, []]);
+
+    nodes[newId][1] = declaredEdges.map(([label, declaredTarget]) => {
+      const observedEdge = observedEdges.find(([edgeLabel]) => edgeLabel === label);
+      return [label, visit(declaredTarget, observedEdge ? observedEdge[1] : null)];
+    });
+
+    return newId;
+  }
+
+  visit(0, 0);
+  return nodes;
+}
+
+function withPattern(value, pattern) {
+  if (!pattern) return value;
+  if (value.pattern === pattern) return value;
+  if (value instanceof Product) return new Product(value.product, pattern);
+  if (value instanceof Variant) return new Variant(value.tag, value.value, pattern);
+  return value;
+}
+
+class Product extends Value {
+  constructor(product, pattern = null) {
+    super("{}", pattern);
+    this.product = product;
+  }
+
+  toString() {
+    return `{${Object.entries(this.product).map(([k, v]) => `${JSON.stringify(k)}:${v.toString()}`).join(',')}}`;
+  }
+
+  toJSON() {
+    let vector = toVector(this.product);
+    if (vector.length > 0) return vector;
+    return this.product; 
+  }
+}
+
+class Variant extends Value {
+  constructor(tag, value, pattern = null) {
+    super("<>", pattern);
+    this.tag = tag;
+    this.value = value;
+  }
+
+  toString() {
+    // return `{${JSON.stringify(this.tag)}:${this.value.toString()}}`;
+    return `${this.value.toString()}|${pLabel(this.tag)}`;
+  }
+
+  toJSON() {
+    if (this.value instanceof Product && Object.keys(this.value.product).length === 0) {
+      return this.tag;
+    }
+    return {[this.tag]: this.value.toJSON()};
+  }
+}
+export { Value, Product, Variant, fromObject, cloneSubpattern, edgeSubpattern, composePattern, mergePatterns, withPattern };
+export default { Value, Product, Variant, fromObject, cloneSubpattern, edgeSubpattern, composePattern, mergePatterns, withPattern };

package/augmentation.mjs

@@ -0,0 +1,198 @@
+import codes from "./codes.mjs";
+
+const unitCode = codes.unitCode;
+
+export function augment(rel, rootDef, rels, representatives) {
+  try {
+    switch (rel.op) {
+      case "product":
+        rel["product"].forEach(({label, exp}) => {
+          augment(exp, rootDef, rels, representatives)
+        });
+        augmentProduct(rel,rootDef);
+        break;
+      case "union":
+        rel["union"].forEach((exp) => {
+          augment(exp,rootDef, rels, representatives);
+        });
+        augmentUnion(rel,rootDef);
+        break;
+      case "comp":
+        rel["comp"].forEach((exp) => {
+          augment(exp,rootDef, rels, representatives);
+        });
+        augmentComp(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 "ref":
+          augmentRef(rel, rootDef, rels);
+          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: '{...}', fields: [rel.dot]}, { [rel.dot]: [rel.patterns[1]] }); 
+        break;
+      case "div":
+        rel.patterns = [];
+        rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '<...>', fields: [rel.div]}, { [rel.div]: [rel.patterns[1]] }); 
+        //console.log(`AUGMENTED DIV: patterns=${JSON.stringify(rel.patterns.map(x => rootDef.typePatternGraph.get_pattern(x)))}`);
+        break;
+      case "vid":
+        rel.patterns = [];
+        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '<...>', fields: [rel.vid]}, { [rel.vid]: [rel.patterns[0]] }); 
+        break;
+      case "filter":
+        rel.patterns = [];
+        rel.patterns[1] = rel.patterns[0] = filterToPattern(rel.filter, rootDef, representatives);
+        break;
+      default:
+        console.error("NOT EXPECTED OP for augmentation:", JSON.stringify(rel, null, 2));
+        break;
+    }
+  } catch (e) {
+    e.message = `Type Error in '${rel.op}' (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column})\n - ${e.message}`;
+    throw e;
+  }   
+}
+
+function filterToPattern(filter, rootDef, representatives) {
+  const context = rootDef.patternVars;
+  const getFields = () => 
+    Object.keys(filter.fields || {}).reduce( (fields, label) => {
+      const patternId = filterToPattern(filter.fields[label], rootDef, representatives);
+      fields[label] = [patternId];
+      return fields;
+    }, {});
+  if (filter.name && ! (filter.name in context)) {
+    context[filter.name] = rootDef.typePatternGraph.addNewNode();
+  }
+  let newPatternId = null;
+  switch (filter.type) {
+    case "name":
+      newPatternId = context[filter.name];
+      break;
+    case "code":
+      newPatternId = rootDef.typePatternGraph.getTypeId(representatives[filter.code] || filter.code);
+      break;
+    case "union":
+      newPatternId = rootDef.typePatternGraph.addNewNode(
+        {pattern: filter.open ? '<...>' : '<>', fields: Object.keys(filter.fields || {})},
+        getFields());
+      break;
+    case "product": 
+      newPatternId = rootDef.typePatternGraph.addNewNode(
+        {pattern: filter.open ? '{...}' : '{}', fields: Object.keys(filter.fields || {})},
+        getFields());
+      break;
+    default:
+      if (!filter.open || Object.keys(filter.fields || {}).length !== 0) {
+        throw new Error("Unknown-kind filters must be exactly '(...)'. Use '{}'/'<>' for closed product/union or '{...}'/'<...>' for open product/union.");
+      }
+      newPatternId = rootDef.typePatternGraph.addNewNode({pattern: '(...)'});
+  }
+  if (filter.name) {
+    rootDef.typePatternGraph.unify(`filter: ${filter.name}`, newPatternId, context[filter.name]);
+  }
+  return newPatternId;
+}
+
+function augmentProduct(rel,rootDef) {
+  rel.patterns = [];
+  if (rel.product.length == 0) {
+      rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+      rel.patterns[1] = rootDef.typePatternGraph.getTypeId(unitCode);
+  } else {
+      // 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]));
+    
+    rel.patterns[1] = rootDef.typePatternGraph.addNewNode(
+      {pattern: '{}', fields: rel.product.map(({label}) => label)},
+      rel.product.reduce((edges, {label, exp}) => {
+        edges[label] = [ rootDef.typePatternGraph.find(exp.patterns[1])];
+        return edges;
+      }, {})
+    );
+  };
+}
+
+function augmentUnion(rel,rootDef) {
+  rel.patterns = [];
+  if (rel.union.length == 0) {
+    rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+    rel.patterns[1] = rootDef.typePatternGraph.addNewNode(); 
+  } 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]));
+  }
+}
+
+function augmentComp(rel,rootDef) {
+  // console.log(`AUGMENTING COMP: ${JSON.stringify(rel.comp)}`);
+  rel.patterns = [];
+  if (rel.comp.length == 0) { 
+    rel.patterns[0] = rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
+  } else {
+    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]
+      );
+    }
+
+    rel.patterns[0] = rel.comp[0].patterns[0];  
+    rel.patterns[1] = rel.comp[rel.comp.length - 1].patterns[1];
+  }
+  // console.log(`AUGMENTED COMP: patterns=${JSON.stringify(rel.patterns.map(i => {
+  //   const x = rootDef.typePatternGraph.find(i);
+  //   return [x,rootDef.typePatternGraph.get_pattern(x)];
+  // }))}`);
+}
+
+function augmentRef(rel,rootDef,rels) { 
+  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;
+    default:
+      throw new Error(`No definition found for '${rel.ref}'`);  
+  }
+}