@fraczak/k 3.1.0 → 4.0.1

package/patterns.mjs

@@ -27,11 +27,17 @@ function relDefToString(relDef) {
       case "dot":
       case "code":
       case "pipe":  
-        return [...rel.patterns];
+      case "filter":
+        return [...rel.patterns]; 
     }
-    throw new Error("NOT EXPECTED OP:", rel);
+    throw new Error("NOT EXPECTED OP:", JSON.stringify(rel, null, 2));
   };
 
+  // console.log("SIZE", relDef.typePatternGraph.size());
+  // console.log(relDef.typePatternGraph.patterns.nodes);
+  // console.log(relDef.typePatternGraph.edges);
+  // console.log(relDef.def);
+  
   return JSON.stringify(dumpPatterns(relDef.def).map((x) => {
     const { pattern, fields, type} = relDef.typePatternGraph.get_pattern(x);
     return {pattern, fields, type};
@@ -39,13 +45,11 @@ function relDefToString(relDef) {
 }
 
 function compactRel(relDef, name = "") {
+  // console.log("********************************* compacting", name);
   const {def, typePatternGraph, varRefs } = relDef;
   // console.log("COMPACTING typePatternGraph of size", typePatternGraph.size());
 
-  const newTypePatternGraph = new TypePatternGraph();
-  const renumbering = typePatternGraph.cloneAll(newTypePatternGraph);
-
-  newTypePatternGraph.turnSingletonPatternsIntoCodes();
+  const {typePatternGraph : newTypePatternGraph, remapping: renumbering}  = typePatternGraph.getCompressed();
 
   const copyRel = (rel) => {
     const newRel = {...rel, patterns:[renumbering[rel.patterns[0]], renumbering[rel.patterns[1]]]};
@@ -72,9 +76,10 @@ function compactRel(relDef, name = "") {
       case "dot":
       case "code":
       case "pipe":
+      case "filter":
         break;
       default:
-        console.error("NOT EXPECTED OP:", rel);
+        console.error("NOT EXPECTED OP:", JSON.stringify(rel, null, 2));
         break;
     };
     return newRel;
@@ -90,8 +95,7 @@ function compactRel(relDef, name = "") {
   return {def: newDef, typePatternGraph: newTypePatternGraph, varRefs: newVarRefs};
 }
 
-function patterns(usedCodes, representatives, rels) {
-  codes.register(usedCodes);
+function patterns(representatives, rels) {
   // INPUT: 
   //   codes: {"BG": {"code": "product", "product": {}}, ...}
   //   representatives:{"{}": "BG", ...}
@@ -175,17 +179,68 @@ function patterns(usedCodes, representatives, rels) {
           rel.patterns[1] = rootDef.typePatternGraph.addNewNode();
           rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '(...)'}, { [rel.dot]: [rel.patterns[1]] }); 
           break;
-        
+        case "filter":
+          rel.patterns = [];
+          rel.patterns[1] = rel.patterns[0] = filterToPattern(rel.filter, rootDef);
+          break;
         default:
-          console.error("NOT EXPECTED OP:", rel);
+          console.error("NOT EXPECTED OP for aumentation:", JSON.stringify(rel, null, 2));
           break;
       }
     } catch (e) {
-      console.error(`Code Derivation Error for '${rel.op}' (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column}): ${e.message}.`);
+      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) {
+    const context = rootDef.patternVars;
+    const getFields = () => 
+      Object.keys(filter.fields || {}).reduce( (fields, label) => {
+        const patternId = filterToPattern(filter.fields[label], rootDef);
+        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(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;
+      case "vector": {
+          const vector = filterToPattern(filter.vector, rootDef);
+          newPatternId = rootDef.typePatternGraph.addNewNode(
+            {pattern: '[]', fields: ["vector-member"]},
+            {"vector-member": [vector]});
+        };
+        break;
+      default:
+        newPatternId = rootDef.typePatternGraph.addNewNode(
+          {pattern: filter.open ? '(...)' : '()'},
+          getFields());
+    }
+    if (filter.name) {
+      rootDef.typePatternGraph.unify(`filter: ${filter.name}`, newPatternId, context[filter.name]);
+    }
+    
+    return newPatternId;
+  }
+
   function augmentProduct(rel,rootDef) {
     rel.patterns = [];
     switch (rel.product.length) {
@@ -305,7 +360,7 @@ function patterns(usedCodes, representatives, rels) {
         rel.patterns[0] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [rel.patterns[1]]});
         break;
       case "toVEC":
-        rel.patterns[0] = rootDef.typePatternGraph.addNewNode();
+        rel.patterns[0] = rootDef.typePatternGraph.getTypeId('string')
         rel.patterns[1] = rootDef.typePatternGraph.addNewNode({pattern: '[]'}, {"vector-member": [rel.patterns[0]]});
         break;
       case "toDateMsec":
@@ -357,7 +412,9 @@ function patterns(usedCodes, representatives, rels) {
     const rootDef = rels[relName];
     rootDef.typePatternGraph = new TypePatternGraph();
     rootDef.varRefs = []; // the list of non-built references as pointers to AST nodes
+    rootDef.patternVars = {}; 
     augment(rootDef.def, rootDef);
+    delete rootDef.patternVars;
   }
    
   
@@ -429,7 +486,9 @@ function patterns(usedCodes, representatives, rels) {
             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}.`);       
+            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}):
+ - ${e.message}`;       
             throw e;
           }
         }

package/pretty.mjs

@@ -1,3 +1,6 @@
+import { find } from "./codes.mjs";
+import { TypePatternGraph } from "./typing.mjs";
+
 function compareAs(fn) {
   return function (a, b) {
     [a, b] = [a, b].map(fn);
@@ -9,12 +12,12 @@ function compareAs(fn) {
 
 const nameRE = /^[a-zA-Z0-9_][a-zA-Z0-9_?!]*$/;
 
-function prettyCode_labels (codes, representatives, label_ref_map) {
+function prettyCode_labels (representatives, label_ref_map) {
   return Object.keys(label_ref_map)
     .sort( compareAs((x) => x) )
     .map( (label) => {
       const plabel = nameRE.test(label) ? label : `'${label}'`;
-      return `${prettyCode(codes, representatives, {
+      return `${prettyCode(representatives, {
         code: "ref",
         ref: label_ref_map[label],
       })} ${plabel}`;
@@ -22,21 +25,21 @@ function prettyCode_labels (codes, representatives, label_ref_map) {
     .join(", ");
 };
 
-function prettyCode (codes, representatives, codeExp) {
+function prettyCode (representatives, codeExp) {
   switch (codeExp.code) {
     case "ref":
       const name = representatives[codeExp.ref] || codeExp.ref;
       if (name.startsWith(":")) {
-        return prettyCode(codes, representatives, codes[name]);
+        return prettyCode(representatives, find(name));
       } else {
         return name;
       }
     case "product":
-      return `{${prettyCode_labels(codes, representatives, codeExp.product)}}`;
+      return `{${prettyCode_labels(representatives, codeExp.product)}}`;
     case "union":
-      return `< ${prettyCode_labels(codes, representatives, codeExp.union)} >`;
+      return `< ${prettyCode_labels(representatives, codeExp.union)} >`;
     case "vector":
-      return `[${prettyCode(codes,representatives, {code:'ref', ref:codeExp.vector})}]`;
+      return `[${prettyCode(representatives, {code:'ref', ref:codeExp.vector})}]`;
       // return `[${representatives[codeExp.vector] || codeExp.vector}]`;
     default:
       return ":error";
@@ -44,28 +47,31 @@ function prettyCode (codes, representatives, codeExp) {
 };
 
 function prettyFilter (prettyCode, filter) {
-  const fieldsStr = (f) => 
-    Object.keys(f.fields).map( (key) => 
-      `${key}: ${prettyFilter(prettyCode, f.fields[key])}` 
-    ).join(", ") + (f.open ? ", ..." : ""); 
+  const fieldsStr = () => {
+    const fields = Object.keys(filter.fields).map( (key) => 
+      `${prettyFilter(prettyCode, filter.fields[key])} ${key}` 
+    );
+    if (filter.open) fields.push("...");
+    return fields.join(", ");
+  } 
   switch (filter.type) {
+    
+    case "code":
+      return `$${prettyCode({code: "ref",ref: filter.code,})}`;
     case "name":
       return filter.name;
-    case "code":
-      return `$${prettyCode({
-          code: "ref",
-          ref: filter.code,
-        })}`;
     case "vector":
-      return `[${prettyFilter(prettyCode, filter.vector)}]`;
+      return `[${prettyFilter(prettyCode, filter.vector)}]${filter.name ? "=" + filter.name : ""}`;
     case null:
-      return `(${fieldsStr(filter)})`;
+      if (filter.name && Object.keys(filter.fields).length == 0) 
+        return filter.name;
+      return `(${fieldsStr()})${filter.name ? "=" + filter.name : ""}`;
     case "union":
-      return `<${fieldsStr(filter)}>`;
+      return `<${fieldsStr()}>${filter.name ? "=" + filter.name : ""}`;
     case "product":
-      return `{${fieldsStr(filter)}}`;
+      return `{${fieldsStr()}}${filter.name ? "=" + filter.name : ""}`;
   }
-  throw new Error("unreachable");
+  throw new Error(`Unknown filter type ${filter.type} in ${JSON.stringify(filter)}`);
 }
 
 function prettyRel (prettyCode, exp) {
@@ -123,5 +129,76 @@ function prettyRel (prettyCode, exp) {
   return pretty(exp);
 };
 
-export default { prettyCode, prettyRel };
-export { prettyCode, prettyRel };
+
+function patterns2filters(typePatternGraph, ...patternIds) {
+  const newTypePatternGraph = new TypePatternGraph();
+  const renamed = typePatternGraph.clone(patternIds, newTypePatternGraph);
+  const newPatternIds = patternIds.map((id) => newTypePatternGraph.find(renamed[id]));
+
+  // inDegree - all open patterns, i.e. (...), {...}, <...>, 
+  // with inDegree > 1 are variables  
+  const inDegree = newTypePatternGraph.patterns.nodes.map((x) => 0);
+  newPatternIds.forEach( id => inDegree[id]++);
+  newTypePatternGraph.edges.forEach( outEdges => 
+    Object.values( outEdges ).forEach( destMap =>
+      Object.values(destMap).forEach( dst =>  
+        inDegree[dst]++ ) 
+    )
+  );
+
+  // variables - variables which will have to be added as extra filters
+  const variables = inDegree.reduce( (variables, degree, i) => {
+    if (degree > 1) variables[i] = "fresh";
+    return variables;
+  }, {});
+
+  const buildFilter = (path, patternId, i) => {
+    let named_filter = {};
+    const pattern = newTypePatternGraph.get_pattern(patternId);
+    if (variables[patternId] && pattern.pattern != 'type') {
+      const name = `X${patternId}`;
+      if (variables[patternId] == "done") 
+        return { type: 'name', name: name };
+      variables[patternId] = "done";
+      named_filter = { name: name };
+    }
+    
+
+    const edges = newTypePatternGraph.edges[patternId];
+    const fields = () => 
+      Object.keys(edges).reduce( (fields, key) =>{
+        fields[key] = buildFilter([...path, key], Object.values(edges[key])[0], i);
+        return fields;
+      }, {});
+
+    switch (pattern.pattern) {
+      case 'type':
+        return {type: "code", code: pattern.type, ...named_filter};
+      case '[]':
+        return {
+          type: "vector", 
+          vector: buildFilter([...path, "vector-member"], Object.values(edges["vector-member"])[0], i),
+          ...named_filter
+        };
+      case '(...)':
+          return { type: null, open: true, fields: fields(), ...named_filter };
+      case '{...}': 
+        return { type: 'product', open: true, fields: fields(), ...named_filter };
+      case '<...>': 
+        return { type: 'union', open: true, fields: fields(), ...named_filter };
+      case '()':
+        return { type: null, fields: fields(), ...named_filter };
+      case  '{}':
+        return { type: 'product', fields: fields(), ...named_filter };
+      case '<>':
+        return { type: 'union', fields: fields(), ...named_filter };
+    }
+  };
+
+  const filters = newPatternIds.map( (id, i) => buildFilter([], id, i) );
+  return filters;
+
+}
+
+export default { prettyCode, prettyRel, patterns2filters };
+export { prettyCode, prettyRel, patterns2filters };

package/repl.mjs

@@ -1,10 +1,12 @@
 #!/usr/bin/env node
+import readline from "node:readline";
+import fs from "node:fs";
 
 import k from "./index.mjs";
 import {run, closeVector } from "./run.mjs";
-import { prettyCode, prettyRel } from "./pretty.mjs";
+import { prettyCode, prettyRel, patterns2filters } from "./pretty.mjs";
+import { find } from "./codes.mjs";
 
-import fs from "node:fs";
 
 const splice = [].splice;
 
@@ -13,14 +15,16 @@ console.log("Very! experimental repl shell for 'k-language'...");
 const help = function () {
   console.log(" --h          print help");
   console.log(" --a          print codes and relations");
-  console.log(" --c          print codes");
+  console.log(" --c          print aliased codes");
+  console.log(" --C code     print code definition");
   console.log(" --r          print rels");
   console.log(" --p          pretty-print last value");
-  console.log(" --pp         pretty-print last value (abrevaited)");
+  console.log(" --pp         print last value via node.js 'console.log'");
   console.log(" --s reg      store the last value in register 'reg'");
   console.log(" --g reg      get the value from register 'reg'");
   console.log(" --regs       print registers names");
   console.log(" --l file.k   load 'file.k'");
+  console.log(" --x rel      print out the type pattern of 'rel'");
 };
 
 help();
@@ -28,114 +32,153 @@ help();
 const re__l = /^[ \n\t]*(?:--l[ ]+)(.+)[ ]*?$/;
 const re__s = /^[ \n\t]*(?:--s[ ]+)(.+)[ ]*?$/;
 const re__g = /^[ \n\t]*(?:--g[ ]+)(.+)[ ]*?$/;
+const re__x = /^[ \n\t]*(?:--x[ ]+)(.+)[ ]*?$/;
+const re__C = /^[ \n\t]*(?:--C[ ]+)(.+)[ ]*?$/;
 
-const registers = {};
+const rl = readline.createInterface({
+  input: process.stdin,
+  output: process.stdout,
+  prompt: ''
+});
+
+rl.prompt();
+
+rl.on('line', (line) => {
+  // console.log(`Received: ${line}`);
+  evaluate(line);
+  rl.prompt();
+}).on('close', () => {
+  console.log('REPL closed');
+  process.exit(0);
+});
 
-(function (val, buffer) {
-  return process.stdin.on("data", function (data) {
-    var e, file, first, i, kScript, last, len, line, ref, rest, todo;
-    [first, ...rest] = data.toString("utf8").split("\n");
-    buffer.push(first);
-    if (rest.length > 0) {
-      todo = buffer.join("");
-      (ref = rest), ([...rest] = ref), ([last] = splice.call(rest, -1));
-      buffer = [last];
-      todo = [todo, ...rest];
-      for (i = 0, len = todo.length; i < len; i++) {
-        line = todo[i];
-        if (val === void 0) {
-          val = {};
-        }
-        if (line.match(/^[ \n\t]*(?:--h)?$/)) {
-          // --h
-          help();
-        } else if (line.match(/^[ \n\t]*\^$/)) {
-          val = closeVector(val); 
-          console.log(`=> ${JSON.stringify(val)}`);
-        } else if (line.match(re__l)) {
-          // --l 
-          file = line.match(re__l)[1];
-          console.log(` -- loading file: ${file} ...`);
-          kScript = fs.readFileSync(file).toString();
-          console.log(` ----------------------------- compiling file: ${file} ...`);
-          // console.log(kScript);
-          val = k.compile("+++" + kScript + "\n()")(val);
-          console.log(`=> ${JSON.stringify(val)}`);
-        } else if (line.match(/^[ \n\t]*(?:--a)?$/)) {
-          // --a
-          val = run.defs;
-          console.log(val);
-        } else if (line.match(/^[ \n\t]*(?:--r)?$/)) {
-          console.log(
-            (function (defs, result) {
-              if (defs == null) {
-                return result;
-              }
-              return (function (prettyRel) {
-                var ref1, relName;
-                ref1 = defs.rels;
-                for (relName in ref1) {
-                  result[relName] = prettyRel(ref1[relName].def);
-                }
-                return result;
-              })(
-                prettyRel.bind(
-                  null,
-                  prettyCode.bind(null, defs.codes, defs.representatives)
-                )
-              );
-            })(run.defs, {}));
-        } else if (line.match(/^[ \n\t]*(?:--c)?$/)) {
-          console.log(
-            (function (defs, result) {
-              var codeExp, codeName, ref1;
-              if (defs == null) {
-                return result;
-              }
-              ref1 = defs.codes;
-              for (codeName in ref1) {
-                codeExp = ref1[codeName];
-                result[codeName] = prettyCode(
-                  defs.codes,
-                  defs.representatives,
-                  codeExp
-                );
-              }
-              return result;
-            })(run.defs, {})
+let val = {};
+const registers = {};
+const buffer = [];
+function evaluate(line) {
+  if (line.trim().endsWith('\\')) {
+    buffer.push(line.slice(0, -1));
+    return;
+  }
+  line = [...buffer, line].join('\n');
+  buffer.length = 0;
+  try {
+    if (val === void 0) {
+      val = {};
+    }
+    if (line.match(/^[ \n\t]*(?:--h)?$/)) {
+      // --h
+      help();
+    } else if (line.match(/^[ \n\t]*\^$/)) {
+      val = closeVector(val); 
+      console.log(`=> ${JSON.stringify(val)}`);
+    } else if (line.match(re__l)) {
+      // --l 
+      const file = line.match(re__l)[1];
+      console.log(` -- loading file: ${file} ...`);
+      const kScript = fs.readFileSync(file).toString();
+      console.log(` ----------------------------- compiling file: ${file} ...`);
+      // console.log(kScript);
+      val = k.compile("+++\n" + kScript + "\n()")(val);
+      console.log(`=> ${JSON.stringify(val)}`);
+    } else if (line.match(/^[ \n\t]*(?:--a)?$/)) {
+      // --a
+      val = run.defs;
+      console.log(val);
+      // --r
+    } else if (line.match(/^[ \n\t]*(?:--r)?$/)) {
+      console.log(
+        (function (defs, result) {
+          if (defs == null) {
+            return result;
+          }
+          return (function (prettyRel) {
+            let ref1, relName;
+            ref1 = defs.rels;
+            for (relName in ref1) {
+              result[relName] = prettyRel(ref1[relName].def);
+            }
+            return result;
+          })(
+            prettyRel.bind(
+              null,
+              prettyCode.bind(null, defs.representatives)
+            )
           );
-          // --pp
-        } else if (line.match(/^[ \n\t]*(?:--pp)?$/)) {
-          console.log(val);
-          // --s
-         // --p
-        } else if (line.match(/^[ \n\t]*(?:--p)?$/)) {
-          console.log(JSON.stringify(val, null, 2));
-          // --s
-        } else if (line.match(/^[ \n\t]*(?:--regs)?$/)) {
-          console.log(` -- registers: ${Object.keys(registers).join(", ")}`);
-        } else if (line.match(re__s)) {
-          let reg = line.match(re__s)[1];
-          registers[reg] = val;
-          console.log(` -- current value stored in register: '${reg}'`);
-          // --g
-        } else if (line.match(re__g)) {
-          console.log(" -- getting value from register...");
-          let reg = line.match(re__g)[1];
-          val = registers[reg];
-          console.log(val);
-          // ------ k code
-        } else if (!line.match(/^[ \n\t]*(?:#.*)?$/)) {
-          try {
-            val = k.run(`+++ ${line} ()`, val);
-            console.log(`=> ${JSON.stringify(val)}`);
-          } catch (error) {
-            e = error;
-            console.error("ERROR:");
-            console.error(e);
+        })(run.defs, {}));
+        // --c
+    } else if (line.match(/^[ \n\t]*(?:--c)?$/)) {
+      console.log(
+        (function (defs, result) {
+          for (const codeName of Object.keys(defs.representatives || {})) {
+            const codeExp = find(defs.representatives[codeName] || codeName);
+            result[codeName] = prettyCode(
+              defs.representatives,
+              codeExp
+            );
           }
-        }
+          return result;
+        })(run.defs || {}, {})
+      );
+      // --C
+    } else if (line.match(re__C)) {
+      let codeName = line.match(re__C)[1];
+      if (codeName.startsWith("?"))
+        codeName = codeName.slice(1);
+      if (codeName.startsWith("$"))
+        codeName = codeName.slice(1);
+      const canonicalName = run.defs.representatives[codeName] || codeName;
+      const codeExp = find( canonicalName );
+      console.log(` $ ${canonicalName} = ${prettyCode(run.defs.representatives, codeExp)}; -- ${codeExp.def}`);
+      // --pp
+    } else if (line.match(/^[ \n\t]*(?:--pp)?$/)) {
+      console.log(val);
+    // --p
+    } else if (line.match(/^[ \n\t]*(?:--p)?$/)) {
+      console.log(JSON.stringify(val, null, 2));
+      // --regs
+    } else if (line.match(/^[ \n\t]*(?:--regs)?$/)) {
+      console.log(` -- registers: ${Object.keys(registers).join(", ")}`);
+      // --s
+    } else if (line.match(re__s)) {
+      let reg = line.match(re__s)[1];
+      registers[reg] = val;
+      console.log(` -- current value stored in register: '${reg}'`);
+      // --g
+    } else if (line.match(re__g)) {
+      console.log(" -- getting value from register...");
+      let reg = line.match(re__g)[1];
+      val = registers[reg];
+      console.log(val);
+        // --x
+    } else if (line.match(re__x)) {
+      const relName = line.match(re__x)[1];
+      const rel = run.defs?.rels[relName];
+      if (!rel) {
+        console.log(` -- relation '${relName}' not found`);
+        return;
+      }
+      const filters = patterns2filters(rel.typePatternGraph, ...rel.def.patterns);
+      // console.log(filters);
+      // console.log(" variables:", JSON.stringify(variables));
+      // console.log(JSON.stringify({filters, variables}, null, 2));
+      // for (const filter of filters) {
+      const pcodef= prettyCode.bind(null, run.defs.representatives);
+      const filtersStr = filters.map( x => prettyRel(pcodef, {op: "filter", filter: x}));
+      console.log(`  ${relName} :  ${filtersStr[0]}  -->  ${filtersStr[1]}`);
+      // }
+      // ------ k code
+    } else if (!line.match(/^[ \n\t]*(?:#.*)?$/)) {
+      try {
+        val = k.run(`+++\n${line}\n()`, val);
+        console.log(`=> ${JSON.stringify(val)}`);
+      } catch (error) {
+        e = error;
+        console.error("ERROR:");
+        console.error(e);
       }
     }
-  });
-})({}, []);
+  } catch (e) {
+    console.error(e.message);
+  }
+}

package/run.mjs

@@ -1,4 +1,5 @@
 import assert from "assert";
+import { find } from "./codes.mjs";
 
 const modulo = (a, b) => ((+a % (b = +b)) + b) % b;
 const valid = (x) => (isNaN(x) ? undefined : x);
@@ -54,7 +55,7 @@ const builtin = {
   },
   FDIV: ([x, y]) => x / y,
   CONCAT: (strs) => strs.join(""),
-  toVEC: (str) => [...str],
+  toVEC: (str) => [...`${str}`],
   true: () => true,
   false: () => false,
   null: () => null,
@@ -73,12 +74,9 @@ const codes = {
 };
 
 function verify(code, value) {
-  if (code == null) {
-    // representatives = run.defs.representatives
-    // defCodes = JSON.stringify run.defs.codes
-    // console.log {code,value, representatives, defCodes}
-    return false;
-  }
+  "use strict";
+  if (code == null) return false;
+  code = find(code);
   switch (code.code) {
     case "vector":
       if (!Array.isArray(value)) return false;
@@ -99,11 +97,8 @@ function verify(code, value) {
         if (fields.length !== 1) return false;
         return verify(code.union[fields[0]], value[fields[0]]);
       }
-    default: {
-      const c = run.defs.codes[run.defs.representatives[code]];
-      if (c != null) return verify(c, value);
-      return codes[code](value);
-    }
+    default: 
+      return codes[code.code](value);
   }
 }
 

package/symbol-table.mjs

@@ -124,7 +124,7 @@ class SymbolTable {
 
   add_rel(name, rel) {
     if (this.rels[name] != undefined)
-      console.error(`SymbolTable: rel ${name} already defined (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column})`);
+      console.error(`SymbolTable: rel '${name}' is redefined (lines ${rel.start?.line}:${rel.start?.column}...${rel.end?.line}:${rel.end?.column})`);
 
     this.rels[name] = {def: rel};
   }