@fraczak/k 1.0.1 → 1.1.1

package/run.coffee

@@ -2,7 +2,10 @@ valid = (x) ->
   return undefined if isNaN x
   return x if x?
 
-builtin = 
+builtin =
+  "_log!": (arg) ->
+    console.log "_log!: #{JSON.stringify arg}"
+    arg
   "GT": (args) ->
     [ok,_] = do ([last,args...] = args) ->
       args.reduce ([ok,last], x) ->
@@ -32,20 +35,57 @@ builtin =
   "null": -> null
   "toJSON": (x) -> JSON.stringify x
   "fromJSON": (x) -> JSON.parse x
+  "CONS": ([x,y]) -> [x,y...]
+  "SNOC": (x) ->
+    return [x[0],x.slice 1] if x.length > 1 
 
+codes =
+  "int": (x) -> 
+    Number.isInteger x
+  "string": (x) ->
+    (x instanceof String) or ('string' is typeof x) 
+  "bool": (x) ->
+    x is true or x is false
+
+verify = (code, value) ->
+  # console.log {code,value}
+  switch code.code
+    when "vector"
+      value.every (x) ->
+        verify code.vector, x
+    when "product"
+      do (fields = Object.keys(value)) ->
+        return false unless fields.length is Object.keys(code.product).length
+        fields.every (label) ->
+          verify code.product[label], value[label]
+    when "union"
+      do (fields = Object.keys(value)) ->
+        return false unless fields.length is 1
+        verify code.union[fields[0]], value[fields[0]]
+    else 
+      do (c = run.defs.codes[run.defs.representatives[code]]) ->
+        return verify c, value if c?  
+        codes[code] value
 
 run = (exp, value) ->
+  # console.log {exp,value}
   return undefined if value is undefined
   try 
     switch exp.op
+      when "code"
+        return value if verify exp.code, value
       when "identity"
         return value
       when "str", "int"
         return exp[exp.op]
       when "ref"
-        return do (value = builtin[exp.ref] value) ->
-          throw new Error "Undefined" if value is undefined
-          value          
+        do (defn = run.defs.rels[exp.ref]?[0]) ->
+          if defn?
+            run defn, value
+          else  
+            do ( value = builtin[exp.ref] value ) -> 
+              throw new Error "Undefined" if value is undefined
+              value          
       when "dot"
         return value[exp.dot]
       when "comp"
@@ -71,6 +111,8 @@ run = (exp, value) ->
             result[label] = value
             result
         , {}
+      else  
+        console.log exp.op
 
 
 module.exports = run

package/run.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
 (function() {
-  var builtin, run, valid,
+  var builtin, codes, run, valid, verify,
     modulo = function(a, b) { return (+a % (b = +b) + b) % b; };
 
   valid = function(x) {
@@ -13,6 +13,10 @@
   };
 
   builtin = {
+    "_log!": function(arg) {
+      console.log(`_log!: ${JSON.stringify(arg)}`);
+      return arg;
+    },
     "GT": function(args) {
       var _, ok;
       [ok, _] = (function([last, ...args]) {
@@ -83,28 +87,93 @@
     },
     "fromJSON": function(x) {
       return JSON.parse(x);
+    },
+    "CONS": function([x, y]) {
+      return [x, ...y];
+    },
+    "SNOC": function(x) {
+      if (x.length > 1) {
+        return [x[0], x.slice(1)];
+      }
+    }
+  };
+
+  codes = {
+    "int": function(x) {
+      return Number.isInteger(x);
+    },
+    "string": function(x) {
+      return (x instanceof String) || ('string' === typeof x);
+    },
+    "bool": function(x) {
+      return x === true || x === false;
+    }
+  };
+
+  verify = function(code, value) {
+    // console.log {code,value}
+    switch (code.code) {
+      case "vector":
+        return value.every(function(x) {
+          return verify(code.vector, x);
+        });
+      case "product":
+        return (function(fields) {
+          if (fields.length !== Object.keys(code.product).length) {
+            return false;
+          }
+          return fields.every(function(label) {
+            return verify(code.product[label], value[label]);
+          });
+        })(Object.keys(value));
+      case "union":
+        return (function(fields) {
+          if (fields.length !== 1) {
+            return false;
+          }
+          return verify(code.union[fields[0]], value[fields[0]]);
+        })(Object.keys(value));
+      default:
+        return (function(c) {
+          if (c != null) {
+            return verify(c, value);
+          }
+          return codes[code](value);
+        })(run.defs.codes[run.defs.representatives[code]]);
     }
   };
 
   run = function(exp, value) {
-    var e, i, len, ref, result;
+    var e, i, len, ref, ref1, result;
     if (value === void 0) {
+      // console.log {exp,value}
       return void 0;
     }
     try {
       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":
-          return (function(value) {
-            if (value === void 0) {
-              throw new Error("Undefined");
+          return (function(defn) {
+            if (defn != null) {
+              return run(defn, value);
+            } else {
+              return (function(value) {
+                if (value === void 0) {
+                  throw new Error("Undefined");
+                }
+                return value;
+              })(builtin[exp.ref](value));
             }
-            return value;
-          })(builtin[exp.ref](value));
+          })((ref = run.defs.rels[exp.ref]) != null ? ref[0] : void 0);
         case "dot":
           return value[exp.dot];
         case "comp":
@@ -125,9 +194,9 @@
             return result;
           });
         case "union":
-          ref = exp.union;
-          for (i = 0, len = ref.length; i < len; i++) {
-            e = ref[i];
+          ref1 = exp.union;
+          for (i = 0, len = ref1.length; i < len; i++) {
+            e = ref1[i];
             result = (function() {
               try {
                 return run(e, value);
@@ -148,6 +217,8 @@
               return result;
             })(run(exp, value));
           }, {});
+        default:
+          return console.log(exp.op);
       }
     } catch (error) {}
   };

package/symbol-table.coffee

@@ -1,8 +1,31 @@
+rels = Object.create null
+codes = Object.create null
+codes["{}"] = {code: "product", product: {}}
+
 identity = op: "identity"
 
+is_identity_rel = (rel) ->
+  rel.op is "identity"
+
+is_empty_rel = (rel) ->
+  rel.op is "union" and rel.union.length is 0
+  
+is_full_rel = (rel) ->
+  switch rel.op
+    when "int", "str", "identity"
+      true
+    when "comp"
+      rel.comp.every is_full_rel
+    when "product", "vector"
+      Object.values(rel[rel.op]).every is_full_rel
+    else  
+      false
+
 comp = (e1, e2) ->
-    return e2 if e1.op is "identity"
-    return e1 if e2.op is "identity"
+    return e2 if is_identity_rel e1
+    return e1 if is_identity_rel e2
+    return e1 if is_empty_rel e1
+    return e2 if is_empty_rel e2
     if e1.op is "comp" and e2.op is "comp"
       return {op: "comp", comp: [].concat(e1.comp,e2.comp)}
     if e1.op is "comp"
@@ -11,4 +34,31 @@ comp = (e1, e2) ->
       return {op: "comp", comp: [].concat([e1],e2.comp)}
     {op: "comp", comp: [e1,e2]}
 
-module.exports = {identity, comp};
+union = (rels) ->
+  list = []
+  do ->
+    for rel in rels
+      new_rels = if rel.op is "union"
+        rel.union
+      else 
+        [rel]
+      for rel in new_rels
+        list.push rel
+        return if is_full_rel rel 
+  return list[0] if list.length is 1
+  {op: "union", union: list}
+    
+as_ref = (codeExp) ->
+  return codeExp.ref if codeExp.code is "ref"
+  newName = ":#{Object.keys(codes).length}"
+  codes[newName] = codeExp
+  return newName
+
+add_rel = (name, rel) ->
+  rels[name] ?= [] 
+  rels[name].push rel
+
+add_code = (name, code) ->
+  codes[name] = code
+
+module.exports = {identity, comp, union, rels, codes, add_rel, add_code, as_ref};

package/symbol-table.js

@@ -1,18 +1,57 @@
 // Generated by CoffeeScript 2.7.0
 (function() {
-  var comp, identity;
+  var add_code, add_rel, as_ref, codes, comp, identity, is_empty_rel, is_full_rel, is_identity_rel, rels, union;
+
+  rels = Object.create(null);
+
+  codes = Object.create(null);
+
+  codes["{}"] = {
+    code: "product",
+    product: {}
+  };
 
   identity = {
     op: "identity"
   };
 
+  is_identity_rel = function(rel) {
+    return rel.op === "identity";
+  };
+
+  is_empty_rel = function(rel) {
+    return rel.op === "union" && rel.union.length === 0;
+  };
+
+  is_full_rel = function(rel) {
+    switch (rel.op) {
+      case "int":
+      case "str":
+      case "identity":
+        return true;
+      case "comp":
+        return rel.comp.every(is_full_rel);
+      case "product":
+      case "vector":
+        return Object.values(rel[rel.op]).every(is_full_rel);
+      default:
+        return false;
+    }
+  };
+
   comp = function(e1, e2) {
-    if (e1.op === "identity") {
+    if (is_identity_rel(e1)) {
       return e2;
     }
-    if (e2.op === "identity") {
+    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",
@@ -37,6 +76,53 @@
     };
   };
 
-  module.exports = {identity, comp};
+  union = function(rels) {
+    var list;
+    list = [];
+    (function() {
+      var i, j, len, len1, new_rels, rel;
+      for (i = 0, len = rels.length; i < len; i++) {
+        rel = rels[i];
+        new_rels = rel.op === "union" ? rel.union : [rel];
+        for (j = 0, len1 = new_rels.length; j < len1; j++) {
+          rel = new_rels[j];
+          list.push(rel);
+          if (is_full_rel(rel)) {
+            return;
+          }
+        }
+      }
+    })();
+    if (list.length === 1) {
+      return list[0];
+    }
+    return {
+      op: "union",
+      union: list
+    };
+  };
+
+  as_ref = function(codeExp) {
+    var newName;
+    if (codeExp.code === "ref") {
+      return codeExp.ref;
+    }
+    newName = `:${Object.keys(codes).length}`;
+    codes[newName] = codeExp;
+    return newName;
+  };
+
+  add_rel = function(name, rel) {
+    if (rels[name] == null) {
+      rels[name] = [];
+    }
+    return rels[name].push(rel);
+  };
+
+  add_code = function(name, code) {
+    return codes[name] = code;
+  };
+
+  module.exports = {identity, comp, union, rels, codes, add_rel, add_code, as_ref};
 
 }).call(this);

package/test.coffee

@@ -32,3 +32,19 @@ console.log ""
   console.log "k_fn(#{JSON.stringify(data)});"
   console.log "// RETURNS: #{JSON.stringify k_fn data}"
   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 (data) -> 
+  console.log "k_fn(#{JSON.stringify(data)});"
+  console.log "// RETURNS: #{JSON.stringify k_fn data}"
+  console.log ""

package/test.js

@@ -73,4 +73,47 @@
     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("");
+  });
+
 }).call(this);

package/{test.t → test.k}

@@ -2,7 +2,7 @@
 <                          -- merge of 4 partial functions...
   ["x=", .x, " & y=", .y], -- produces a vector of 4 values, if fields 'x' and 'y' are present
   ["only x=", .x],         -- produces a pair '["only x=", "value-of-x"]', for input like {"x":"value-of-x"}
-							-- it is defined only if field 'x' is present
+							             -- it is defined only if field 'x' is present
   ["only y=", .y],
   ["no x nor y"]           -- defined for all input, returns always the same one element vector
 >