@fraczak/k 1.3.3 → 2.0.0

package/run.mjs

@@ -0,0 +1,142 @@
+const modulo = (a, b) => ((+a % (b = +b)) + b) % b;
+const valid = (x) => (isNaN(x) ? undefined : x);
+
+const builtin = {
+  "_log!": (arg) => {
+    console.error(`_log!: ${JSON.stringify(arg)}`);
+    return arg;
+  },
+  GT: (args) => {
+    const [last, ...rest] = args;
+    const [ok, _] = rest.reduce(
+      ([ok, last], x) => [ok && last > x, x],
+      [true, last]
+    );
+    if (ok) return args;
+  },
+  EQ: (args) => {
+    const [first, ...rest] = args;
+    const ok = rest.reduce((ok, x) => ok && first === x, true);
+    if (ok) return args;
+  },
+  PLUS: (args) => valid(args.reduce((res, x) => res + x, 0)),
+  TIMES: (args) => valid(args.reduce((res, x) => res * x, 1)),
+  DIV: ([x, y]) => {
+    const div = Math.floor(x / y);
+    const rem = modulo(x, y);
+    if (x === div * y + rem) return { div, rem };
+  },
+  FDIV: ([x, y]) => x / y,
+  CONCAT: (strs) => strs.join(""),
+  true: () => true,
+  false: () => false,
+  null: () => null,
+  toJSON: (x) => JSON.stringify(x),
+  fromJSON: (x) => JSON.parse(x),
+  CONS: ([x, y]) => [x, ...y],
+  SNOC: (x) => (x.length > 1 ? [x[0], x.slice(1)] : undefined),
+  toDateMsec: (x) => new Date(x).getTime(),
+  toDateStr: (x) => new Date(x).toISOString(),
+};
+
+const codes = {
+  int: (x) => Number.isInteger(x),
+  string: (x) => x instanceof String || "string" === typeof x,
+  bool: (x) => x === true || x === false,
+};
+
+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;
+  }
+  switch (code.code) {
+    case "vector":
+      if (!Array.isArray(value)) return false;
+      return value.every((x) => verify(code.vector, x));
+    case "product":
+      if ("object" !== typeof value) return false;
+      else {
+        const fields = Object.keys(value);
+        if (fields.length !== Object.keys(code.product).length) return false;
+        return fields.every((label) =>
+          verify(code.product[label], value[label])
+        );
+      }
+    case "union":
+      if ("object" !== typeof value) return false;
+      else {
+        const fields = Object.keys(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);
+    }
+  }
+}
+
+function run(exp, value) {
+  "use strict";
+  if (value === undefined) return;
+  switch (exp.op) {
+    case "code":
+      if (verify(exp.code, value)) {
+        return value;
+      }
+      break;
+    case "identity":
+      return value;
+    case "str":
+    case "int":
+      return exp[exp.op];
+    case "ref":
+      const defn = run.defs.rels[exp.ref];
+      if (defn != null) {
+        return run(defn[defn.length - 1], value);
+      }
+      return builtin[exp.ref](value);
+    case "dot":
+      return value[exp.dot];
+    case "comp":
+      return exp.comp.reduce((value, exp) => {
+        if (value !== undefined) return run(exp, value);
+      }, value);
+    case "union":
+      for (let i = 0, len = exp.union.length; i < len; i++) {
+        const result = run(exp.union[i], value);
+        if (result !== undefined) {
+          return result;
+        }
+      }
+      return;
+    case "vector": {
+      const result = [];
+      for (let i = 0, len = exp.vector.length; i < len; i++) {
+        const r = run(exp.vector[i], value);
+        if (r === undefined) return;
+        result.push(r);
+      }
+      return result;
+    }
+    case "product": {
+      const result = {};
+      for (let i = 0, len = exp.product.length; i < len; i++) {
+        const { label, exp: e } = exp.product[i];
+        const r = run(e, value);
+        if (r === undefined) return;
+        result[label] = r;
+      }
+      return result;
+    }
+    default:
+      return console.error(exp.op);
+  }
+}
+
+export default run;
+export { run };

package/symbol-table.mjs

@@ -0,0 +1,133 @@
+const rels = {};
+const codes = {
+  "{}": {
+    code: "product",
+    product: {},
+  },
+};
+
+const identity = {
+  op: "identity",
+};
+
+function is_identity_rel(rel) {
+  return rel.op === "identity";
+}
+
+function is_constant_rel(rel) {
+  switch (rel.op) {
+    case "int":
+    case "str":
+      return true;
+    case "vector":
+      return Object.values(rel[rel.op]).every(is_constant_rel);
+    case "product":
+      return Object.values(rel[rel.op]).every(({ exp }) =>
+        is_constant_rel(exp)
+      );
+    default:
+      return false;
+  }
+}
+
+function is_empty_rel(rel) {
+  return rel.op === "union" && rel.union.length === 0;
+}
+
+function is_full_rel(rel) {
+  if (is_constant_rel(rel)) return true;
+  switch (rel.op) {
+    case "int":
+    case "str":
+    case "identity":
+      return true;
+    case "comp":
+      return rel.comp.every(is_full_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));
+    default:
+      return false;
+  }
+}
+
+function comp_first(e1, e2) {
+  if (is_identity_rel(e1)) return e2;
+  if (is_identity_rel(e2)) return e1;
+  if (is_empty_rel(e1)) return e1;
+  if (is_empty_rel(e2)) return e2;
+  if (e1.op === "comp" && e2.op === "comp")
+    return {
+      op: "comp",
+      comp: [].concat(e1.comp, e2.comp),
+    };
+  if (e1.op === "comp")
+    return {
+      op: "comp",
+      comp: [].concat(e1.comp, [e2]),
+    };
+  if (e2.op === "comp")
+    return {
+      op: "comp",
+      comp: [].concat([e1], e2.comp),
+    };
+  return {
+    op: "comp",
+    comp: [e1, e2],
+  };
+}
+
+function comp (e1, e2)  {
+  const result = comp_first(e1, e2);
+  if (result.op !== "comp") return result;
+  result.comp = result.comp.reduceRight(
+    (c, e) => (c[0] && is_constant_rel(c[0]) && is_full_rel(e) ? c : [e, ...c]),
+    []
+  );
+  return result;
+}
+
+function union  (rels) {
+  const list = [];
+  label: for (const rel of rels) {
+    const new_rels = rel.op === "union" ? rel.union : [rel];
+    for (const new_rel of new_rels) {
+      list.push(new_rel);
+      if (is_full_rel(new_rel)) break label;
+    }
+  }
+  if (list.length === 1) return list[0];
+  return {
+    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 };

package/test.mjs

@@ -0,0 +1,143 @@
+import k from "./index.mjs";
+
+[
+  ["ANYTHING...", "()"],
+  ["ANYTHING...", '{"ala" name, 23 age}'],
+  [
+    {
+      year: 2002,
+      age: 19,
+    },
+    "[.year, .age]",
+  ],
+  ["duplicate me", "[(), ()]"],
+  ["nesting", "[[[()]]]"],
+  ["nesting and accessing", "[[()]] {() nested, .0.0 val}"],
+  [
+    {
+      test: "parse integer",
+    },
+    "0000",
+  ],
+  [
+    {
+      x: 3,
+      y: 4,
+    },
+    "[.y,.x] PLUS",
+  ],
+].map(function ([data, script]) {
+  console.log(`k_expression = '${script}';`);
+  console.log(`k.run(k_expression,${JSON.stringify(data)});`);
+  console.log(`// RETURNS: ${JSON.stringify(k.run(script, data))}`);
+  return console.log("");
+});
+
+let k_expression =
+  '{.name nom, <[.age, 18] GT .0, [.age, 12] GT "ado", "enfant"> age}';
+
+let k_fn = k.compile(k_expression);
+
+console.log(`var k_fn = k.compile('${k_expression}');`);
+
+console.log("");
+
+[
+  {
+    age: 23,
+    name: "Emily",
+  },
+  {
+    age: 16,
+    name: "Katrina",
+  },
+  {
+    age: 2,
+    name: "Mark",
+  },
+].map(function (data) {
+  console.log(`k_fn(${JSON.stringify(data)});`);
+  console.log(`// RETURNS: ${JSON.stringify(k_fn(data))}`);
+  return console.log("");
+});
+
+k_expression = "$t = < i: int, t: [ t ] > ; <$t, $int>";
+
+k_fn = k.compile(k_expression);
+
+console.log(`var k_fn = k.compile('${k_expression}');`);
+
+console.log("");
+
+[
+  1,
+  {
+    i: 1,
+  },
+  [
+    {
+      i: 2,
+    },
+    {
+      i: 3,
+    },
+    {
+      t: [],
+    },
+  ],
+  {
+    t: [
+      {
+        i: 2,
+      },
+      {
+        i: 3,
+      },
+      {
+        t: [],
+      },
+    ],
+  },
+].map(function (data) {
+  console.log(`k_fn(${JSON.stringify(data)});`);
+  console.log(`// RETURNS: ${JSON.stringify(k_fn(data))}`);
+  return console.log("");
+});
+
+k_expression = "$ < < [ int ] ints, [ bool ] bools > list, string None>";
+
+k_fn = k.compile(k_expression);
+
+console.log(`var k_fn = k.compile('${k_expression}');`);
+
+console.log("");
+
+[
+  {
+    None: "None",
+  },
+  {
+    list: {
+      ints: [],
+    },
+  },
+  {
+    list: {
+      ints: [1, 2, 3],
+    },
+  },
+  {
+    list: {
+      bools: [true, false],
+    },
+  },
+  {
+    list: {
+      bools: [true, 0],
+    },
+  },
+].map(function (data) {
+  console.log(`k_fn(${JSON.stringify(data)});`);
+  console.log(`// RETURNS: ${JSON.stringify(k_fn(data))}`);
+  return console.log("");
+});

package/codes.coffee

@@ -1,81 +0,0 @@
-
-are_different = (classes, representatives, name1, name2, codes) ->
-  # console.log {classes, representatives, name1, name2, codes}
-  return false if name1 is name2
-  code1 = codes[name1]
-  code2 = codes[name2]
-  # console.log {name1, code1, name2, code2}
-  return true unless code1.code is code2.code
-  switch code1.code
-    when "union", "product"
-      [fields1,fields2] = [code1, code2]. map (code) ->
-        do (arg = code[code.code]) ->
-          Object.keys(arg).reduce (fields, label) ->
-            fields[label] = representatives[arg[label]] ? arg[label]
-            fields
-          , {}
-      return true unless Object.keys(fields1).length is Object.keys(fields2).length
-      for field,rep of fields1 
-        # console.log {field,rep1:rep,rep2:fields2[field]}
-        return true unless fields2[field] is rep 
-    when "vector"
-      [arg1,arg2] = [code1, code2]. map ({vector}) ->
-        representatives[vector] ? vector
-      return true unless arg1 is arg2
-  false
-
-minimize = (codes) ->
-  names = Object.keys codes
-  classes = {}
-  classes["{}"] = names
-  representatives = names.reduce (representatives, name) ->
-    representatives[name] = "{}"
-    representatives
-  , {}
-  changed = true
-  while changed
-    changed = false
-    for name1, eq_names of classes
-      code = codes[name1]
-      [eq_names, dif_names] = eq_names.reduce ([eq_names, dif_names], name2) ->
-        if are_different(classes, representatives, name1, name2, codes)
-          dif_names.push name2
-        else
-          eq_names.push name2
-        [eq_names,dif_names]
-      , [[],[]]
-      classes[name1] = eq_names
-      do (new_rep = dif_names[0]) ->
-        if new_rep?
-          changed = true
-          classes[new_rep] = dif_names
-          for x in dif_names
-            representatives[x] = new_rep
-  {classes,representatives}
-
-normalize = (label_ref_map, representatives) ->
-  # console.log {label_ref_map, representatives}
-  Object.keys(label_ref_map).reduce (result, label) ->
-    result[label] = do (name = label_ref_map[label]) ->
-      representatives[name] ? name
-    result
-  , {}
-
-normalizeAll = (codes,representatives) ->
-  names = Object.keys codes
-  normalized = names.reduce (normalized, name) ->
-    if name is representatives[name]
-      do (code = codes[name]) ->
-        switch code.code
-          when "union", "product"
-            normalized[name] = { code: code.code } 
-            normalized[name][code.code] = normalize code[code.code], representatives
-          when "vector"
-            normalized[name] = {code:"vector", vector: representatives[code.vector] ? code.vector}
-  
-    normalized    
-  , {}
-
-module.exports = {minimize,normalize,normalizeAll}
-
-

package/codes.js

@@ -1,134 +0,0 @@
-// Generated by CoffeeScript 2.7.0
-(function() {
-  var are_different, minimize, normalize, normalizeAll;
-
-  are_different = function(classes, representatives, name1, name2, codes) {
-    var arg1, arg2, code1, code2, field, fields1, fields2, rep;
-    if (name1 === name2) {
-      // console.log {classes, representatives, name1, name2, codes}
-      return false;
-    }
-    code1 = codes[name1];
-    code2 = codes[name2];
-    if (code1.code !== code2.code) {
-      // console.log {name1, code1, name2, code2}
-      return true;
-    }
-    switch (code1.code) {
-      case "union":
-      case "product":
-        [fields1, fields2] = [code1, code2].map(function(code) {
-          return (function(arg) {
-            return Object.keys(arg).reduce(function(fields, label) {
-              var ref;
-              fields[label] = (ref = representatives[arg[label]]) != null ? ref : arg[label];
-              return fields;
-            }, {});
-          })(code[code.code]);
-        });
-        if (Object.keys(fields1).length !== Object.keys(fields2).length) {
-          return true;
-        }
-        for (field in fields1) {
-          rep = fields1[field];
-          if (fields2[field] !== rep) {
-            
-            // console.log {field,rep1:rep,rep2:fields2[field]}
-            return true;
-          }
-        }
-        break;
-      case "vector":
-        [arg1, arg2] = [code1, code2].map(function({vector}) {
-          var ref;
-          return (ref = representatives[vector]) != null ? ref : vector;
-        });
-        if (arg1 !== arg2) {
-          return true;
-        }
-    }
-    return false;
-  };
-
-  minimize = function(codes) {
-    var changed, classes, code, dif_names, eq_names, name1, names, representatives;
-    names = Object.keys(codes);
-    classes = {};
-    classes["{}"] = names;
-    representatives = names.reduce(function(representatives, name) {
-      representatives[name] = "{}";
-      return representatives;
-    }, {});
-    changed = true;
-    while (changed) {
-      changed = false;
-      for (name1 in classes) {
-        eq_names = classes[name1];
-        code = codes[name1];
-        [eq_names, dif_names] = eq_names.reduce(function([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;
-        (function(new_rep) {
-          var i, len, results, x;
-          if (new_rep != null) {
-            changed = true;
-            classes[new_rep] = dif_names;
-            results = [];
-            for (i = 0, len = dif_names.length; i < len; i++) {
-              x = dif_names[i];
-              results.push(representatives[x] = new_rep);
-            }
-            return results;
-          }
-        })(dif_names[0]);
-      }
-    }
-    return {classes, representatives};
-  };
-
-  normalize = function(label_ref_map, representatives) {
-    // console.log {label_ref_map, representatives}
-    return Object.keys(label_ref_map).reduce(function(result, label) {
-      result[label] = (function(name) {
-        var ref;
-        return (ref = representatives[name]) != null ? ref : name;
-      })(label_ref_map[label]);
-      return result;
-    }, {});
-  };
-
-  normalizeAll = function(codes, representatives) {
-    var names, normalized;
-    names = Object.keys(codes);
-    return normalized = names.reduce(function(normalized, name) {
-      if (name === representatives[name]) {
-        (function(code) {
-          var ref;
-          switch (code.code) {
-            case "union":
-            case "product":
-              normalized[name] = {
-                code: code.code
-              };
-              return normalized[name][code.code] = normalize(code[code.code], representatives);
-            case "vector":
-              return normalized[name] = {
-                code: "vector",
-                vector: (ref = representatives[code.vector]) != null ? ref : code.vector
-              };
-          }
-        })(codes[name]);
-      }
-      return normalized;
-    }, {});
-  };
-
-  module.exports = {minimize, normalize, normalizeAll};
-
-}).call(this);

package/index.coffee

@@ -1,28 +0,0 @@
-{parse} = require "./parser.js"
-run = require "./run"
-t = require "./codes"
-
-
-finalize = (codes) ->
-  representatives = t.minimize(codes).representatives
-  codes = t.normalizeAll codes, representatives
-
-  {codes, representatives}
-
-
-compile = (script) ->
-  do ({defs,exp} = parse script) ->
-    # console.log defs
-    {codes, representatives} = finalize defs.codes
-    # console.log {codes, representatives}
-    run.defs = {codes, representatives, rels: defs.rels}
-    
-    (data) -> run exp, data
-    
-compile.doc = "Transforms k-script (string) into a function"
-
-runScriptOnData = (script, data) ->
-  compile(script) data
-runScriptOnData.doc = "Run 'script' (string) on 'data': (script,data) -> data"
-
-module.exports = {compile, run: runScriptOnData, parse}

package/index.js

@@ -1,49 +0,0 @@
-// Generated by CoffeeScript 2.7.0
-(function() {
-  var compile, finalize, parse, run, runScriptOnData, t;
-
-  ({parse} = require("./parser.js"));
-
-  run = require("./run");
-
-  t = require("./codes");
-
-  finalize = function(codes) {
-    var representatives;
-    representatives = t.minimize(codes).representatives;
-    codes = t.normalizeAll(codes, representatives);
-    return {codes, representatives};
-  };
-
-  compile = function(script) {
-    return (function({defs, exp}) {
-      var codes, representatives;
-      // console.log defs
-      ({codes, representatives} = finalize(defs.codes));
-      // console.log {codes, representatives}
-      run.defs = {
-        codes,
-        representatives,
-        rels: defs.rels
-      };
-      return function(data) {
-        return run(exp, data);
-      };
-    })(parse(script));
-  };
-
-  compile.doc = "Transforms k-script (string) into a function";
-
-  runScriptOnData = function(script, data) {
-    return compile(script)(data);
-  };
-
-  runScriptOnData.doc = "Run 'script' (string) on 'data': (script,data) -> data";
-
-  module.exports = {
-    compile,
-    run: runScriptOnData,
-    parse
-  };
-
-}).call(this);