@fraczak/k 3.1.0 → 4.0.0

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) {
@@ -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

@@ -2,7 +2,8 @@
 
 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";
 
@@ -13,14 +14,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 of 'rel'");
 };
 
 help();
@@ -28,6 +31,8 @@ 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 = {};
 
@@ -42,98 +47,125 @@ const registers = {};
       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);
+        try {
+          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);
+            // --r
+          } else if (line.match(/^[ \n\t]*(?:--r)?$/)) {
+            console.log(
+              (function (defs, result) {
+                if (defs == null) {
+                  return result;
                 }
-                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 (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.representatives)
+                  )
                 );
-              }
-              return result;
-            })(run.defs, {})
-          );
-          // --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`);
+              continue;
+            }
+            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(`+++ ${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);
@@ -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);
   }
 }