@fraczak/k 4.0.3 → 5.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "4.0.3",
+    "version": "5.0.0",
     "description": "k-language for JSON-like data transformation",
     "main": "index.mjs",
     "scripts": {

package/patterns.mjs

@@ -3,6 +3,7 @@ import hash from "./hash.mjs";
 import { TypePatternGraph } from "./typing.mjs";
 import { Graph, sccs, topoOrder } from "./Graph.mjs";
 import codes from "./codes.mjs";
+import { assignCanonicalNames } from "./export.mjs";
 
 const unitCode = codes.unitCode;
 
@@ -101,6 +102,7 @@ function patterns(representatives, rels) {
   //   representatives:{"{}": "BG", ...}
   //   rels: {"rlz": [{op: comp,...}, ...], ...}
  
+  const relAlias = {};
 
   // 1 INITIALIZATION
   // 1.1 initialize patternNodes and rels
@@ -416,7 +418,7 @@ function patterns(representatives, rels) {
   for (const relName in rels) {
     const rootDef = rels[relName];
     rootDef.typePatternGraph = new TypePatternGraph();
-    rootDef.varRefs = []; // the list of non-built references as pointers to AST nodes
+    rootDef.varRefs = []; // the list of references to non-builtin rels as pointers to AST nodes
     rootDef.patternVars = {}; 
     augment(rootDef.def, rootDef);
     delete rootDef.patternVars;
@@ -453,12 +455,16 @@ function patterns(representatives, rels) {
 
   // 3. Topological sort of the DAG
 
-  const sccInOrder = topoOrder(DAG);
+  const sccInOrder = topoOrder(DAG).reverse();
 
   // 4. For each strongly connected component C in a bottom-up order
+  
+  //    we will also generate the canonical representation of the relations in C and replace 
+  //    the name to the relation by the hash of the canonical representation    
+
+  // console.log("----- SCC in order", sccInOrder);
 
-  for (const scc of sccInOrder.reverse()) {
-    // console.log(`SCC: { ${DAGnodes[scc].scc} }`);
+  for (const scc of sccInOrder) {
 
     const maxNumberOfIterations = 10;
     
@@ -497,9 +503,7 @@ function patterns(representatives, rels) {
             throw e;
           }
         }
-
         rels[relName] = compactRel(relDef,relName);
-        
         return relDefToString(rels[relName]); 
       }));
 
@@ -507,9 +511,19 @@ function patterns(representatives, rels) {
         // console.log("SUCCESS!");
         break;
       }
-    } // while
-      
+    } // end of iteration loop
+
+    DAGnodes[scc].scc.forEach( relName => {
+      const relDef = rels[relName];
+      const canonical = relDefToString(relDef);
+      const h = hash(canonical);
+      relAlias[relName] = h;
+    });
+
+    assignCanonicalNames(DAGnodes[scc].scc, rels, relAlias);
+
   }
+  return relAlias;
 }
 
 export default { patterns };

package/pretty.mjs

@@ -1,26 +1,22 @@
 import { find } from "./codes.mjs";
 import { TypePatternGraph } from "./typing.mjs";
 
-function compareAs(fn) {
-  return function (a, b) {
-    [a, b] = [a, b].map(fn);
-    if (a < b) return -1;
-    if (a > b) return 1;
-    return 0;
-  };
-}
-
 const nameRE = /^[a-zA-Z0-9_][a-zA-Z0-9_?!]*$/;
+function pLabel_(label) {
+  return nameRE.test(label) ? ` ${label}` : `${JSON.stringify(label)}`;
+}
+function pLabel(label) {
+  return nameRE.test(label) ? `${label}` : `${JSON.stringify(label)}`;
+}
 
 function prettyCode_labels (representatives, label_ref_map) {
   return Object.keys(label_ref_map)
-    .sort( compareAs((x) => x) )
+    .sort()
     .map( (label) => {
-      const plabel = nameRE.test(label) ? label : `'${label}'`;
       return `${prettyCode(representatives, {
         code: "ref",
         ref: label_ref_map[label],
-      })} ${plabel}`;
+      })}${pLabel_(label)}`;
     })
     .join(", ");
 };
@@ -46,10 +42,10 @@ function prettyCode (representatives, codeExp) {
   }
 };
 
-function prettyFilter (prettyCode, filter) {
+function prettyFilter ( filter ) {
   const fieldsStr = () => {
     const fields = Object.keys(filter.fields).map( (key) => 
-      `${prettyFilter(prettyCode, filter.fields[key])} ${key}` 
+      `${prettyFilter(filter.fields[key])}${pLabel_(key)}` 
     );
     if (filter.open) fields.push("...");
     return fields.join(", ");
@@ -57,11 +53,11 @@ function prettyFilter (prettyCode, filter) {
   switch (filter.type) {
     
     case "code":
-      return `$${prettyCode({code: "ref",ref: filter.code,})}`;
+      return `$${filter.code}`;
     case "name":
       return filter.name;
     case "vector":
-      return `[${prettyFilter(prettyCode, filter.vector)}]${filter.name ? "=" + filter.name : ""}`;
+      return `[${prettyFilter(filter.vector)}]${filter.name ? "=" + filter.name : ""}`;
     case null:
       if (filter.name && Object.keys(filter.fields).length == 0) 
         return filter.name;
@@ -74,12 +70,13 @@ function prettyFilter (prettyCode, filter) {
   throw new Error(`Unknown filter type ${filter.type} in ${JSON.stringify(filter)}`);
 }
 
-function prettyRel (prettyCode, exp) {
+function prettyRel (exp) {
   "use strict";
   const pretty = (exp) => {
     switch (exp.op) {
       case "filter":
-        return `?${prettyFilter(prettyCode, exp.filter)}`;
+        if (exp.filter.type == 'code') return `$${exp.filter.code}`;
+        return `?${prettyFilter(exp.filter)}`;
       case "pipe":
         return `|`;        
       case "caret":
@@ -101,27 +98,16 @@ function prettyRel (prettyCode, exp) {
       case "dot":
         if ("number" === typeof exp.dot) {
           return `.${exp.dot}`;
-        } else if (nameRE.test(exp.dot)) {
-          return `.${exp.dot}`;
-        } else {
-          return `'${exp.dot}'`;
-        }
-        break;
+        } else 
+          return `.${pLabel(exp.dot)}`;
       case "code":
-        return `$${prettyCode({
-          code: "ref",
-          ref: exp.code,
-        })}`;
+        return `$${exp.code}`;
       case "product":
         return (function (labelled) {
           return `{${labelled.join(", ")}}`;
         })(
           exp.product.map(function ({ label, exp }) {
-            if (nameRE.test(label)) {
-              return `${pretty(exp)} ${label}`;
-            } else {
-              return `${pretty(exp)} '${label}'`;
-            }
+              return `${pretty(exp)}${pLabel_(label)}`;
           })
         );
     }
@@ -148,25 +134,24 @@ function patterns2filters(typePatternGraph, ...patternIds) {
 
   // variables - variables which will have to be added as extra filters
   const variables = inDegree.reduce( (variables, degree, i) => {
-    if (degree > 1) variables[i] = "fresh";
+    if (degree > 1) variables[i] = true;
     return variables;
   }, {});
 
+  const filterVars = {};
   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 };
+      if (filterVars[patternId]) 
+        return { type: 'name', name: filterVars[patternId] };
+      filterVars[patternId] = `X${Object.keys(filterVars).length}`;
+      named_filter = { name: filterVars[patternId] };
     }
     
-
     const edges = newTypePatternGraph.edges[patternId];
     const fields = () => 
-      Object.keys(edges).reduce( (fields, key) =>{
+      Object.keys(edges).sort().reduce( (fields, key) =>{
         fields[key] = buildFilter([...path, key], Object.values(edges[key])[0], i);
         return fields;
       }, {});

package/repl.mjs

@@ -6,14 +6,17 @@ import k from "./index.mjs";
 import {run, closeVector } from "./run.mjs";
 import { prettyCode, prettyRel, patterns2filters } from "./pretty.mjs";
 import { find } from "./codes.mjs";
+import { exportRelation } from "./export.mjs";
 
 
-const splice = [].splice;
+let DEBUG_FLAG = false;
 
 console.log("Very! experimental repl shell for 'k-language'...");
 
 const help = function () {
-  // console.log("  --debug      loads codes and relations as value");
+  console.log(`  --debug        toggle debug flag: [${DEBUG_FLAG?'ON':'OFF'}]`);
+  if (DEBUG_FLAG)
+    console.log("  --load         loads codes and relations as value");
   console.log("  --c            print aliased codes");
   console.log("  --C code       print 'code' definition");
   console.log("  --r            print relations");
@@ -88,40 +91,42 @@ function evaluate(line) {
       // console.log(kScript);
       val = k.compile("+++\n" + kScript + "\n()")(val);
       printVal();
-    } else if (line.match(/^[ \n\t]*--debug$/)) {
       // --debug
+    } else if (line.match(/^[ \n\t]*--debug$/)) {
+      DEBUG_FLAG = ! DEBUG_FLAG;
+      // --load
+    } else if (line.match(/^[ \n\t]*--load$/)) {
       val = run.defs;
       console.log(val);
       // --r
     } else if (line.match(/^[ \n\t]*(?:--r)?$/)) {
-      console.log(
+      console.log("BUILT-IN:", run.builtin);
+      console.log("USER-DEFINED:",
         (function (defs, result) {
           if (defs == null) {
             return result;
           }
-          return (function (prettyRel) {
-            for (const relName in defs.rels) {
-              if (relName != "__main__")
-                result[relName] = prettyRel(defs.rels[relName].def);
-            }
-            return result;
-          })(
-            prettyRel.bind(
-              null,
-              prettyCode.bind(null, defs.representatives)
-            )
-          );
+          
+          for (const relName in defs.rels) {
+            if (relName != "__main__")
+              result[relName] = prettyRel(defs.rels[relName].def);
+          }
+          return result;
         })(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
-            );
+            const codeRep = defs.representatives[codeName] || codeName;
+            if (codeName == codeRep) {
+              result[codeName] = prettyCode(
+                defs.representatives,
+                find(codeRep)
+              );
+            } else if (! codeName.startsWith(":")) {
+              result[codeName] = codeRep;
+            }
           }
           return result;
         })(run.defs || {}, {})
@@ -161,18 +166,33 @@ function evaluate(line) {
       const relName = line.match(re__R)[1];
       const rel = run.defs?.rels[relName];
       if (!rel) {
+        if (relName in run.builtin) {
+          console.log(` -- builtin relation: ${relName}\n    ${relName} = ${run.builtin[relName]}`);
+          return;
+        }
         console.log(` -- relation '${relName}' not found`);
         return;
       }
+      const canonicalRelName = run.defs.relAlias[relName];
       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]}`);
-      console.log(`  ${relName} = ${prettyRel(pcodef,rel.def)};`);
+      const filtersStr = filters.map( x => prettyRel( {op: "filter", filter: x}));
+      // console.log(` -- canonical relation name: ${canonicalRelName} --`);
+      // console.log(`  ${relName} : ${filtersStr[0]}  -->  ${filtersStr[1]}`);
+      // console.log(`  ${relName} = ${prettyRel(rel.def)};`);
+      // console.log(`  ${relName} = ${prettyRel(rel.simplified)};`);
+      console.log({
+        name: canonicalRelName,
+        type: `${filtersStr[0]}  -->  ${filtersStr[1]}`,
+        def: prettyRel(rel.simplified)
+      });
+      if (DEBUG_FLAG) {
+        val = exportRelation(run.defs.rels, run.defs.relAlias, relName);
+        console.log(val);
+      }
       // }
       // ------ k code
     } else if (!line.match(/^[ \n\t]*(?:#.*)?$/)) {
@@ -180,12 +200,11 @@ function evaluate(line) {
         val = k.run(`+++\n${line}\n()`, val);
         printVal();
       } catch (error) {
-        e = error;
-        console.error("ERROR:");
-        console.error(e);
+        console.error(error.message);
       }
     }
   } catch (e) {
     console.error(e.message);
+    console.error(e);
   }
 }

package/run.mjs

@@ -248,7 +248,9 @@ function run(exp, value) {
       }
       case "caret": {
         const result = run(exp.caret, value);
-        assert(isOpen(result), "CARET (^): Only an 'open' vector can be closed.");
+        // assert(isOpen(result), "CARET (^): Only an 'open' vector can be closed.");
+        if (! isOpen(result))
+          throw new Error(`Type Error (line: ${exp.end?.line}:${exp.end?.column}): CARET (^): Only 'unboxed' values can be 'boxed'.`)
         return [...result];
       }  
       case "filter": {
@@ -261,5 +263,7 @@ function run(exp, value) {
   };
 }
 
+run.builtin = builtin;
+
 export default run;
 export { run , closeVector };

package/TYPES.md

@@ -1,32 +0,0 @@
-# What if we concider partial functions as filter-to-filter mappings?
-
-## Examples
-
-```k
-.x :: ( X x, ... ) -> X
-{ f1 x1, f2 x2, ..., fn xn } :: X -> { f1(X) x1, f2(X) x2, ..., fn(X) xn }
-{ f x } :: X -> < f(X) x, ... >
-< f1, f2, ..., fn > :: X -> f1(X) // f1 == f2 == ... == fn
-[ f1, f2, ..., fn ] :: X -> [f1(X)] // f1 == f2 == ... == fn
-$code :: 
-```
-
-Let's consider the following example:
-
-```k
-$nat = < {} _, nat s >;
-z = {{} _};   -- X -> <{} _, ...>
-s = {() s};   -- X -> <X s, ...>
-
-add = 
-  <
-    {.x ._ if, .y then} .then,
-    {.x .s x, .y s y } add
-  >
-;
-
-double = {() x, () y} add;
-
-z s s $nat double;
-```
-