@fraczak/k 3.0.2 → 4.0.0

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,13 +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(" --pp         pretty-print last value");
+  console.log(" --p          pretty-print last value");
+  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();
@@ -27,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 = {};
 
@@ -41,93 +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();
-          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, relExps, relName;
-                ref1 = defs.rels;
-                for (relName in ref1) {
-                  relExps = ref1[relName];
-                  result[relName] = relExps.map(prettyRel);
+        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, {})
-          );
+              })(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]*(?:--pp)?$/)) {
-          console.log(val);
-          // --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);
+          } 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);
@@ -54,13 +55,14 @@ const builtin = {
   },
   FDIV: ([x, y]) => x / y,
   CONCAT: (strs) => strs.join(""),
+  toVEC: (str) => [...str],
   true: () => true,
   false: () => false,
   null: () => null,
   toJSON: (x) => JSON.stringify(x),
   fromJSON: (x) => JSON.parse(x),
-  CONS: (arg) => { try { return [arg[0], ...arg[1]]; } catch (e) { return undefined; } },
-  SNOC: (x) => (x.length > 1 ? [x[0], x.slice(1)] : undefined),
+  CONS: ({car, cdr}) => { try { return [car, ...cdr]; } catch (e) { return undefined; } },
+  SNOC: (x) => (x.length > 1 ? {car: x[0], cdr: x.slice(1)} : undefined),
   toDateMsec: (x) => new Date(x).getTime(),
   toDateStr: (x) => new Date(x).toISOString(),
 };
@@ -72,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;
@@ -98,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);
   }
 }
 
@@ -131,10 +127,10 @@ function run(exp, value) {
       case "str":
       case "int":
         return exp[exp.op];
-      case "ref":
+      case "ref": {
         const defn = run.defs.rels[exp.ref];
-        if (defn != null) {
-          exp = defn[defn.length - 1];
+        if (defn != undefined) {
+          exp = defn.def;
           continue;
         }
         const builtin_func = builtin[exp.ref];
@@ -142,6 +138,7 @@ function run(exp, value) {
           return builtin_func(value);
         }
         throw(`Unknown ref: '${exp.ref}'`);
+      }
       case "dot":
         // a hack to allow something like 'null . null' or '0 . 0' to work by returning unit
         if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {

package/symbol-table.mjs

@@ -1,14 +1,8 @@
-const rels = {};
-const codes = {
-  "{}": {
-    code: "product",
-    product: {},
-  },
-};
-
-const identity = {
-  op: "identity",
-};
+import hash from "./hash.mjs";
+
+const unitCode = hash('$C0={};'); 
+
+const identity = {op: "identity"}
 
 function is_identity_rel(rel) {
   return rel.op === "identity";
@@ -46,7 +40,9 @@ function is_full_rel(rel) {
     case "vector":
       return Object.values(rel[rel.op]).every(is_full_rel);
     case "product":
-      return Object.values(rel[rel.op]).every(({ exp }) => is_full_rel(exp));
+      return Object.values(rel[rel.op]).every(({ exp }) =>
+        is_full_rel(exp)
+      );
     default:
       return false;
   }
@@ -81,7 +77,7 @@ function comp_first(e1, e2) {
   };
 }
 
-function comp (e1, e2)  {
+function comp(e1, e2) {
   const result = comp_first(e1, e2);
   if (result.op !== "comp") return result;
   result.comp = result.comp.reduceRight(
@@ -91,7 +87,8 @@ function comp (e1, e2)  {
   return result;
 }
 
-function union  (rels) {
+
+function union(rels) {
   const list = [];
   label: for (const rel of rels) {
     const new_rels = rel.op === "union" ? rel.union : [rel];
@@ -105,32 +102,38 @@ function union  (rels) {
     op: "union",
     union: list,
   };
-};
-
-function as_ref (codeExp) {
-  if (codeExp.code === "ref") return codeExp.ref;
-  const newName = `:${Object.keys(codes).length}`;
-  codes[newName] = codeExp;
-  return newName;
-};
-
-function add_rel (name, rel) {
-  if (rels[name] == null) rels[name] = [];
-  rels[name].push(rel);
-};
-
-function add_code (name, code) {
-  codes[name] = code;
 }
 
-export default {
-  identity,
-  comp,
-  union,
-  rels,
-  codes,
-  add_rel,
-  add_code,
-  as_ref,
-};
-export { identity, comp, union, rels, codes, add_rel, add_code, as_ref };
+class SymbolTable {
+  constructor() {
+    this.rels = {}; // name -> {def: rel_exp}
+    this.codes = {
+      [unitCode]: {
+        code: "product",
+        product: {},
+      },
+    };
+  }
+
+  as_ref(codeExp) {
+    if (codeExp.code === "ref") return codeExp.ref;
+    const newName = `:${Object.keys(this.codes).length}`;
+    this.codes[newName] = codeExp;
+    return newName;
+  }
+
+  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})`);
+
+    this.rels[name] = {def: rel};
+  }
+
+  add_code(name, code) {
+    this.codes[name] = code;
+  }
+}
+
+export default { SymbolTable, comp, union, identity };
+export { SymbolTable, comp, union, identity };
+

package/test-filters.mjs

@@ -23,7 +23,7 @@ const annotated = k.annotate(`
 const test1 = unify_with_code(
   annotated.codes, 
   annotated.representatives["pair"], 
-  annotated.rels['f1'][0].filter,
+  annotated.rels['f1'].def.filter,
   {}
 );
 console.log(JSON.stringify(test1, null, 2));
@@ -31,7 +31,7 @@ console.log(JSON.stringify(test1, null, 2));
 const test2 = unify_with_code(
   annotated.codes, 
   annotated.representatives["pair"], 
-  annotated.rels['f2'][0].filter,
+  annotated.rels['f2'].def.filter,
   {}
 );
 console.log(JSON.stringify(test2, null, 2));
@@ -39,7 +39,7 @@ console.log(JSON.stringify(test2, null, 2));
 const test3 = unify_with_code(
   annotated.codes, 
   annotated.representatives["list"], 
-  annotated.rels['f3'][0].filter,
+  annotated.rels['f3'].def.filter,
   {}
 );
 console.log(JSON.stringify(test3, null, 2));

package/typing-test.mjs

@@ -0,0 +1,40 @@
+import t from './typing.mjs';
+// const t = await import('./typing.mjs');
+const g = new t.typePatternGraph();
+
+const pu = {pattern: '(...)', fields: []};
+
+// x = .x;     {   {   5   x }     x  i,  {   true   x }      x   b }
+//    0   1   2  3   4   5    6  7  8    9  10    11    12  13  14  15
+
+for (var i = 0; i < 16; i++) { g.addNewNode(pu); }
+
+g.addNewNode({pattern: '(...)'}, {x: [1]}); // 16
+g.unify("y:input", 0,16); // 17
+
+// 
+g.unify('main:input',2,3,4,9,10); // 18
+
+g.addNewNode({pattern: '{}'}, {i: [8], b: [14]}); // 19
+g.unify("main:output", 15,19); // 20
+
+g.unify('comp:chain',6,7); // 21
+g.unify('comp:chain',12,13); // 22
+
+
+// {5 x}
+g.addNewNode({pattern: '<...>'}, {x: [5]}); // 23
+g.unify('variant:output',6,23); // 24
+
+// {true x}
+g.addNewNode({pattern: '<...>'}, {x: [11]}); // 25
+g.unify('variant:output',12,25); // 26
+
+
+// 5
+g.addNewNode({pattern: 'type', type: 'int'}); // 27
+g.unify('5:outout',5,27); // 28
+
+// true
+g.addNewNode({pattern: 'type', type: 'bool'}); // 29
+g.unify('true:output',11,29); // 30