@fraczak/k 4.0.4 → 5.0.1

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");
@@ -48,8 +51,8 @@ rl.on('line', (line) => {
   process.exit(0);
 });
 
-let old_val = {};
-let val = {};
+let old_val = k.compile("{}")({});
+let val = old_val;
 const printVal = function (v = val) {
   if (v === undefined)
     console.log("...",v);
@@ -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 || {}, {})
@@ -135,6 +140,9 @@ function evaluate(line) {
         codeName = codeName.slice(1);
       const canonicalName = run.defs.representatives[codeName] || codeName;
       const codeExp = find( canonicalName );
+      if (codeExp.def == "builtin") {
+        return console.log(` $ ${canonicalName} = :builtin;`);
+      }
       console.log(` $ ${canonicalName} = ${prettyCode(run.defs.representatives, codeExp)}; -- ${codeExp.def}`);
       // --pp
     } else if (line.match(/^[ \n\t]*(?:--pp)?$/)) {
@@ -161,18 +169,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.def)
+      });
+      if (DEBUG_FLAG) {
+        val = exportRelation(run.defs.rels, run.defs.relAlias, relName);
+        console.log(val);
+      }
       // }
       // ------ k code
     } else if (!line.match(/^[ \n\t]*(?:#.*)?$/)) {

package/run.mjs

@@ -263,5 +263,7 @@ function run(exp, value) {
   };
 }
 
+run.builtin = builtin;
+
 export default run;
 export { run , closeVector };