@fraczak/k 1.3.3 → 2.0.0

package/INTRO.md

@@ -129,7 +129,7 @@ names are integers starting from zero. E.g., `{.toto "0", .titi "1",
       zero? = [(),0] EQ 0;
       factorial = <
         zero? 1, 
-        [(dec factorial), ()] TIMES
+        [dec factorial, ()] TIMES
       >;
       { () x, factorial "x!" }
 
@@ -137,10 +137,24 @@ names are integers starting from zero. E.g., `{.toto "0", .titi "1",
 
 _Codes_ (prefixed by `$`) can be defined by taged union and product. E.g.:
 
-      $nat = <nat 1, {} 0>;     -- e.g., {{{{} 0} 1} 1}
-      $pair = {nat x, nat y};   -- e.g., {{{} 0} x, {{{{} 0} 1} 1} y}
+      $nat = <nat 1, {} 0>;
+      $pair = {nat x, nat y};
       
-      suc = $nat {() 1} $nat;
-      add = $pair <{.x.1 x, .y suc y} add, .y> $nat;
+      suc = {$nat 1};
+      add = $pair <{.x.1 x, .y suc y} add, .y>;
+
+### Basic extension codes
+
+Since _basic extension_ introduces integers, booleans, and strings, there are three 
+predefined types: `int`, `bool`, and `string`. A vector product code can also be defined 
+by `[ codeExp ]`.  All members of the vector are the same code. E.g.,
+
+     $intVector = [ int ];
+     $boolVector = [ bool ];
+     $tree = [ tree ];
+
+     emptyList? = $intVector $[ string ]; -- as only an empty vector can be a vector 
+                                          -- of integers and a vector of strings
+
 
 

package/README.md

@@ -4,8 +4,9 @@
 
 From javascript:
 
-    var k  = require("@fraczak/k"),
-        fn = k.compile("<.name,.nom,'?'>");
+    import k from "@fraczak/k";
+    
+    const fn = k.compile("<.name,.nom,'?'>");
     console.log([{name:"x"},{nom:"y"},{}].map(fn));
     // returns: [ "x", "y", "?" ]
 

package/codes.mjs

@@ -0,0 +1,104 @@
+function are_different(classes, representatives, name1, name2, codes) {
+  if (name1 === name2) return false;
+  const code1 = codes[name1];
+  const code2 = codes[name2];
+  if (code1.code !== code2.code) return true;
+  switch (code1.code) {
+    case "union":
+    case "product":
+      const [fields1, fields2] = [code1, code2].map((code) => {
+        const arg = code[code.code];
+        return Object.keys(arg).reduce((fields, label) => {
+          const ref = representatives[arg[label]];
+          fields[label] = ref != null ? ref : arg[label];
+          return fields;
+        }, {});
+      });
+      if (Object.keys(fields1).length !== Object.keys(fields2).length)
+        return true;
+
+      for (const field in fields1) {
+        if (fields2[field] !== fields1[field]) return true;
+      }
+      break;
+    case "vector":
+      const [arg1, arg2] = [code1, code2].map(
+        ({ vector }) => representatives[vector] || vector
+      );
+      if (arg1 !== arg2) return true;
+  }
+  return false;
+}
+
+function minimize(codes) {
+  const names = Object.keys(codes);
+  const classes = {};
+  classes["{}"] = names;
+  const representatives = names.reduce((representatives, name) => {
+    representatives[name] = "{}";
+    return representatives;
+  }, {});
+  let changed = true;
+  while (changed) {
+    changed = false;
+    for (const name1 in classes) {
+      const [eq_names, dif_names] = classes[name1].reduce(
+        ([eq_names, dif_names], name2) => {
+          if (are_different(classes, representatives, name1, name2, codes)) {
+            dif_names.push(name2);
+          } else {
+            eq_names.push(name2);
+          }
+          return [eq_names, dif_names];
+        },
+        [[], []]
+      );
+      classes[name1] = eq_names;
+
+      if (dif_names.length > 0) {
+        const new_rep = dif_names[0];
+        changed = true;
+        classes[new_rep] = dif_names;
+        dif_names.forEach((name) => (representatives[name] = new_rep));
+      }
+    }
+  }
+  return { classes, representatives };
+}
+
+function normalize(label_ref_map, representatives) {
+  return Object.keys(label_ref_map).reduce((result, label) => {
+    const name = label_ref_map[label];
+    result[label] = representatives[name] || name;
+    return result;
+  }, {});
+}
+
+function normalizeAll(codes, representatives) {
+  return Object.keys(codes).reduce(function (normalized, name) {
+    if (name === representatives[name]) {
+      const code = codes[name];
+
+      switch (code.code) {
+        case "union":
+        case "product":
+          normalized[name] = { code: code.code };
+          normalized[name][code.code] = normalize(
+            code[code.code],
+            representatives
+          );
+          break;
+        case "vector":
+          normalized[name] = {
+            code: "vector",
+            vector: representatives[code.vector] || code.vector,
+          };
+      }
+    }
+
+    return normalized;
+  }, {});
+}
+
+export default { minimize, normalize, normalizeAll };
+export { minimize, normalize, normalizeAll };

package/index.mjs

@@ -0,0 +1,35 @@
+import { parse } from "./parser.mjs";
+
+import run from "./run.mjs";
+
+import t from "./codes.mjs";
+
+function finalize(codes) {
+  const representatives = t.minimize(codes).representatives;
+  return {
+    codes: t.normalizeAll(codes, representatives),
+    representatives,
+  };
+}
+
+function compile(script) {
+  const { defs, exp } = parse(script);
+  const { codes, representatives } = finalize(defs.codes);
+  run.defs = {
+    codes,
+    representatives,
+    rels: defs.rels,
+  };
+  return run.bind(null, exp);
+}
+
+compile.doc = "Transforms k-script (string) into a function";
+
+function runScriptOnData(script, data) {
+  return compile(script)(data);
+}
+runScriptOnData.doc = "Run 'script' (string) on 'data': (script,data) -> data";
+
+export default { compile, run: runScriptOnData, parse };
+
+export { compile, runScriptOnData as run, parse };

package/k.mjs

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import k from "./index.mjs";
+
+const splice = [].splice;
+
+const prog = process.argv[1];
+
+let kScript, jsonStream, oneJson;
+
+({ kScript, jsonStream, oneJson } = (function (oneJson, args) {
+  let e;
+  try {
+    kScript = (function (arg) {
+      if (arg == null) {
+        throw new Error();
+      }
+      if (arg === "-k") {
+        return fs.readFileSync(args.shift()).toString("utf8");
+      } else {
+        return arg;
+      }
+    })(args.shift());
+    kScript = k.compile(kScript);
+    jsonStream = (function (arg) {
+      if (arg === "-1") {
+        oneJson = true;
+        arg = args.shift();
+      }
+      if (arg == null) {
+        return process.stdin;
+      }
+      return fs.createReadStream(arg);
+    })(args.shift());
+    return { kScript, jsonStream, oneJson };
+  } catch (error) {
+    e = error;
+    console.error(e);
+    console.error(`Usage: ${prog} ( k-expr | -k k-file ) [ -1 ] [ json-file ]`);
+    console.error(`       E.g.,  echo '{\"a\": 12}' | ${prog} '[(),()]'`);
+    return process.exit(-1);
+  }
+})(false, process.argv.slice(2)));
+
+if (oneJson) {
+  (function (buffer) {
+    jsonStream.on("data", function (data) {
+      return buffer.push(data);
+    });
+    return jsonStream.on("end", function () {
+      var e;
+      try {
+        return console.log(
+          JSON.stringify(kScript(JSON.parse(buffer.join(""))))
+        );
+      } catch (error) {
+        e = error;
+        return console.error(e);
+      }
+    });
+  })([]);
+} else {
+  (function (buffer, line) {
+    return jsonStream.on("data", function (data) {
+      var e, first, i, json, last, len, ref, rest, results, 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];
+        results = [];
+        for (i = 0, len = todo.length; i < len; i++) {
+          json = todo[i];
+          if (!json.match(/^[ \n\t]*(?:#.*)?$/)) {
+            try {
+              console.log(JSON.stringify(kScript(JSON.parse(json))));
+            } catch (error) {
+              e = error;
+              console.error(`Problem [line ${line}]: '${json}'`);
+              console.error(e);
+            }
+          }
+          results.push((line = line + 1));
+        }
+        return results;
+      }
+    });
+  })([], 0);
+}

package/package.json

@@ -1,13 +1,11 @@
 {
     "name": "@fraczak/k",
-    "version": "1.3.3",
+    "version": "2.0.0",
     "description": "k-language for JSON-like data transformation",
-    "main": "index.js",
+    "main": "index.mjs",
     "scripts": {
-        "prepare": "coffee -c symbol-table.coffee; jiwson parser.jison",
-        "prepublishOnly": "coffee -c *.coffee; echo '#!/usr/bin/env node' | cat - k.js > k.sh; echo '#!/usr/bin/env node' | cat - repl.js > repl.sh;",
-        "all": "coffee -c *.coffee; npm run prepare; npm run prepublishOnly",
-        "test": "coffee -c symbol-table.coffee; jiwson parser.jison; coffee test.coffee"
+        "prepare": "jiwson -m es6 parser.jison -o parser.mjs",
+        "test": "node test.mjs"
     },
     "repository": {
         "type": "git",
@@ -16,11 +14,10 @@
     "author": "Wojciech Fraczak",
     "license": "ISC",
     "bin": {
-        "k": "./k.sh",
-        "k-repl": "./repl.sh"
+        "k": "./k.mjs",
+        "k-repl": "./repl.mjs"
     },
     "devDependencies": {
-        "coffeescript": "^2.7.0",
         "jiwson": "^0.1.1"
     }
 }

package/parser.jison

@@ -1,6 +1,26 @@
 %{
 
-var s = require("./symbol-table");
+import s from "./symbol-table.mjs";
+
+function fromEscString(escString) {
+  const isSingleQuoted = escString.startsWith("'");
+  let str = escString.substring(1, escString.length - 1);
+  if (isSingleQuoted) {
+    str = str.replace(/\\'/g, "'");
+  } else {
+    str = str.replace(/\\"/g, '"');
+  }
+  str = str.replace(/\\\\/g, '\\');
+  str = str.replace(/\\\//g, '/');
+  str = str.replace(/\\b/g, '\b');
+  str = str.replace(/\\f/g, '\f');
+  str = str.replace(/\\n/g, '\n');
+  str = str.replace(/\\r/g, '\r');
+  str = str.replace(/\\t/g, '\t');
+  str = str.replace(/\\u([\dA-F]{4})/gi, (match, p1) => String.fromCharCode(parseInt(p1, 16)));
+
+  return str;
+}
 
 %}
 
@@ -24,7 +44,7 @@ var s = require("./symbol-table");
 ";"                                            return 'SC';
 ":"                                            return 'COL';
 "$"                                            return 'DOLLAR'; 
-\"[^\"\n]*\"|\'[^\'\n]*\'                      return 'STRING'
+\"([^"\\]|\\(.|\n))*\"|\'([^'\\]|\\(.|\n))*\'  return 'STRING';
 [a-zA-Z_][a-zA-Z0-9_?!]*                       return 'NAME';
 0|[-]?[1-9][0-9]*                              return 'INT';
 <<EOF>>                                        return 'EOF';
@@ -40,11 +60,11 @@ var s = require("./symbol-table");
 %%
 
 name: NAME                              { $$ = String(yytext); };
-str: STRING                             { $$ = String(yytext).slice(1,-1); };
+str: STRING                             { $$ = fromEscString(String(yytext)); };
 int: INT                                { $$ = parseInt(String(yytext)); };
 
 input_with_eof: defs comp EOF               {
-    result = {defs: {rels: s.rels, codes: s.codes}, exp: $2};
+    const result = {defs: {rels: s.rels, codes: s.codes}, exp: $2};
     // console.log(JSON.stringify(result, "", 2));
     return result;
 };

package/{parser.js → parser.mjs}

@@ -1,3 +1,4 @@
+
 /* parser generated by jison 0.1.1 */
 /*
   Returns a Parser object of the following structure:
@@ -74,7 +75,27 @@
 
 
 
-var s = require("./symbol-table");
+import s from "./symbol-table.mjs";
+
+function fromEscString(escString) {
+  const isSingleQuoted = escString.startsWith("'");
+  let str = escString.substring(1, escString.length - 1);
+  if (isSingleQuoted) {
+    str = str.replace(/\\'/g, "'");
+  } else {
+    str = str.replace(/\\"/g, '"');
+  }
+  str = str.replace(/\\\\/g, '\\');
+  str = str.replace(/\\\//g, '/');
+  str = str.replace(/\\b/g, '\b');
+  str = str.replace(/\\f/g, '\f');
+  str = str.replace(/\\n/g, '\n');
+  str = str.replace(/\\r/g, '\r');
+  str = str.replace(/\\t/g, '\t');
+  str = str.replace(/\\u([\dA-F]{4})/gi, (match, p1) => String.fromCharCode(parseInt(p1, 16)));
+
+  return str;
+}
 
 
 
@@ -94,14 +115,14 @@ case 1:
  this.$ = String(yytext); 
 break;
 case 2:
- this.$ = String(yytext).slice(1,-1); 
+ this.$ = fromEscString(String(yytext)); 
 break;
 case 3:
  this.$ = parseInt(String(yytext)); 
 break;
 case 4:
 
-    result = {defs: {rels: s.rels, codes: s.codes}, exp: $$[$0-1]};
+    const result = {defs: {rels: s.rels, codes: s.codes}, exp: $$[$0-1]};
     // console.log(JSON.stringify(result, "", 2));
     return result;
 
@@ -713,7 +734,7 @@ case 15:return 28;
 break;
 case 16:return 15; 
 break;
-case 17:return 6
+case 17:return 6;
 break;
 case 18:return 4;
 break;
@@ -723,7 +744,7 @@ case 20:return 12;
 break;
 }
 },
-rules: [/^(?:[/][*]([*][^/]|[^*])*[*][/])/,/^(?:(\/\/|#|%|--)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:"[^\"\n]*"|'[^\'\n]*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:$)/],
+rules: [/^(?:[/][*]([*][^/]|[^*])*[*][/])/,/^(?:(\/\/|#|%|--)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:"([^"\\]|\\(.|\n))*"|'([^'\\]|\\(.|\n))*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:$)/],
 conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],"inclusive":true}}
 });
 return lexer;
@@ -736,20 +757,11 @@ Parser.prototype = parser;parser.Parser = Parser;
 return new Parser;
 })();
 
-
-if (typeof require !== 'undefined' && typeof exports !== 'undefined') {
-exports.parser = parser;
-exports.Parser = parser.Parser;
-exports.parse = function () { return parser.parse.apply(parser, arguments); };
-exports.main = function commonjsMain (args) {
-    if (!args[1]) {
-        console.log('Usage: '+args[0]+' FILE');
-        process.exit(1);
-    }
-    var source = require('fs').readFileSync(require('path').normalize(args[1]), "utf8");
-    return exports.parser.parse(source);
-};
-if (typeof module !== 'undefined' && require.main === module) {
-  exports.main(process.argv.slice(1));
+const ___parser = parser;
+const ___Parser = parser.Parser;
+const ___parse = parser.parse.bind(parser);
+export {
+___parser as parser,
+___Parser as Parser,
+___parse as parse 
 }
-}

package/pretty.mjs

@@ -0,0 +1,95 @@
+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 prettyCode_labels (codes, 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, {
+        code: "ref",
+        ref: label_ref_map[label],
+      })} ${plabel}`;
+    })
+    .join(", ");
+};
+
+function prettyCode (codes, representatives, codeExp) {
+  switch (codeExp.code) {
+    case "ref":
+      const name = representatives[codeExp.ref] || codeExp.ref;
+      if (name.startsWith(":")) {
+        return prettyCode(codes, representatives, codes[name]);
+      } else {
+        return name;
+      }
+    case "product":
+      return `{${prettyCode_labels(codes, representatives, codeExp.product)}}`;
+    case "union":
+      return `<${prettyCode_labels(codes, representatives, codeExp.union)}>`;
+    case "vector":
+      return `[${representatives[codeExp.vector] || codeExp.vector}]`;
+    default:
+      return ":error";
+  }
+};
+
+function prettyRel (prettyCode, exp) {
+  "use strict";
+  const pretty = (exp) => {
+    switch (exp.op) {
+      case "vector":
+        return `[${exp.vector.map(pretty).join(", ")}]`;
+      case "union":
+        return `<${exp.union.map(pretty).join(", ")}>`;
+      case "ref":
+        return exp.ref;
+      case "identity":
+        return "()";
+      case "comp":
+        return exp.comp.map(pretty).join(" ");
+      case "str":
+        return `'${exp.str}'`;
+      case "int":
+        return exp.int;
+      case "dot":
+        if ("number" === typeof exp.dot) {
+          return `.${exp.dot}`;
+        } else if (nameRE.test(exp.dot)) {
+          return `.${exp.dot}`;
+        } else {
+          return `'${exp.dot}'`;
+        }
+        break;
+      case "code":
+        return `$${prettyCode({
+          code: "ref",
+          ref: 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);
+};
+
+export default { prettyCode, prettyRel };
+export { prettyCode, prettyRel };

package/repl.mjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import k from "./index.mjs";
+import run from "./run.mjs";
+import { prettyCode, prettyRel } from "./pretty.mjs";
+
+import fs from "node:fs";
+
+const splice = [].splice;
+
+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(" --r          print rels");
+  return console.log(" --l file.k   load 'file.k'");
+};
+
+help();
+
+const re = /^[ \n\t]*(?:--l[ ]+)(.+[^ ])[ ]*?$/;
+
+(function (val, buffer) {
+  return process.stdin.on("data", function (data) {
+    var e, file, first, i, kScript, last, len, line, ref, rest, results, 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];
+      results = [];
+      for (i = 0, len = todo.length; i < len; i++) {
+        line = todo[i];
+        if (val === void 0) {
+          val = {};
+        }
+        if (line.match(/^[ \n\t]*(?:--h)?$/)) {
+          results.push(help());
+        } else if (line.match(re)) {
+          file = line.match(re)[1];
+          console.log(`-- loading file: ${file} ...`);
+          kScript = fs.readFileSync(file).toString();
+          val = k.compile(kScript)(val);
+          results.push(console.log(`=> ${JSON.stringify(val)}`));
+        } else if (line.match(/^[ \n\t]*(?:--a)?$/)) {
+          results.push(console.log(JSON.stringify(run.defs, " ", 2)));
+        } else if (line.match(/^[ \n\t]*(?:--r)?$/)) {
+          results.push(
+            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);
+                  }
+                  return result;
+                })(
+                  prettyRel.bind(
+                    null,
+                    prettyCode.bind(null, defs.codes, defs.representatives)
+                  )
+                );
+              })(run.defs, {})
+            )
+          );
+        } else if (line.match(/^[ \n\t]*(?:--c)?$/)) {
+          results.push(
+            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, {})
+            )
+          );
+        } else if (!line.match(/^[ \n\t]*(?:#.*)?$/)) {
+          try {
+            val = k.run(`${line} ()`, val);
+            results.push(console.log(`=> ${JSON.stringify(val)}`));
+          } catch (error) {
+            e = error;
+            console.error("ERROR:");
+            results.push(console.error(e));
+          }
+        } else {
+          results.push(void 0);
+        }
+      }
+      return results;
+    }
+  });
+})({}, []);