@fraczak/k 1.1.0 → 1.1.2

package/README.md

@@ -1,5 +1,7 @@
 # k-language 
 
+	npm install @fraczak/k
+
 Another JSON transformation notation.  A `k`-expression
 (script) defines a __partial function__, i.e., a function which, in
 general, is not defined for every input. `k`-expressions can be
@@ -48,18 +50,18 @@ Elementary partial functions are:
 3.  There is a number of built-in functions: `GT`, `EQ`, `PLUS`,
 	`TIMES`, `MINUS`, `DIV`, `CONCAT`, `toJSON`, `fromJSON`, `CONS`, `SNOC`. For example
 	
-		[1, 2, 3] PLUS       --> integer constant 6
-		[4, 4] TIMES toJSON  --> string constant "16"
-		[3, 2] GT            --> vector constant [3, 2]
+		[1, 2, 3] PLUS       --> integer constant function 6
+		[4, 4] TIMES toJSON  --> string constant function "16"
+		[3, 2] GT            --> vector constant function [3, 2]
 		[3, 4] GT            --> is not defined!
 		
 	A more interesting example could be:
 	
-		< [.0, .1] GT, [.1, .0] GT > .0
+		< GT .0, .1>
 		
-	which selects the bigger of two first integers of a vector argument, i.e.,
+	which selects the maximum element in two element vector, i.e.,
 	
-		[3,8] < [.0, .1] GT, [.1, .0] GT > .0    --> 8
+		[3,8] < GT .0, .1 >    --> 8
 
 ## User defined functions
 
@@ -70,18 +72,33 @@ Elementary partial functions are:
 	  [1,()] GT 1,
 	  [dec factorial, ()] TIMES
 	>;
-	{ x: (), "x!": factorial }
+	{ () x, factorial "x!" }
+
+Another example could be finding the biggest (max) value in a vector:
 
-## Value encodings (also called _types_ or _codes_)
+	max = < 
+	  SNOC         -- [x0, x1, x2, ...] -> [x0, [x1, x2, ...]]
+	  [.0, .1 max] -- [x0, [x1, x2, ...]] -> [x0, max(x1,x2,...)], i.e., recursive call 
+	  <GT.0,.1>,   -- if x0 > max(x1,x2,...) then x0 else max(x1,x2,...)
+	               -- when SNOC is not defined, e.g. the argument is a singleton vector [x0]
+	  .0           -- [x0] -> x0, 
+	>; 
+	max
+
+## Value encodings (also called _codes_)
 
 There are three predefined value encodings: `int`, `string`, and `bool`. The language
 supports `code`-expressions:
 
-* product, e.g., `{x: int, y: int, flag: bool}`
-* disjoint union, e.g., `<x: string, y: bool>`
+* product, e.g., `{int x, int y, bool flag}` (in JSON-like syntax `{x: int, y: int, flag: bool}`)
+* disjoint union, e.g., `<{} true, {} false>` (in JSON-like syntax `<true: {}, false: {}>`)
 * vector, e.g., `[ int ]` (all elements of the vector use the same encoding)
 
-One can define recursive codes. E.g.,
+One can define recursive codes. E.g.:
+
+	$ tree = <string leaf, {tree left, tree right} tree>;
+
+or, the same in JSON-like notation:
 
 	$ tree = <leaf: string, tree: {left: tree, right: tree}>;
 
@@ -91,11 +108,12 @@ The above example defines new code called _tree_.
 The code can be then used in a `k`-expression as a filter. A `code`-expression
 within `k`-expression is again prefixed by `$`.
 
-	$tree = <leaf: string, tree: {left: tree, right: tree}>;
+	$ tree = <string leaf, {tree left, tree right} tree>;
 	inc = [(),1] PLUS;
+	max = <GT .0, .1>;
 	height = $ tree <
 		.leaf 0,
-		.tree [.left height, .right height] <GT .0, .1> inc
+		.tree [.left height, .right height] max inc
 	> $ int;
 	height
 
@@ -107,7 +125,7 @@ run the language from command line.
 
     $ ./node_modules/.bin/k
 	... errors ...
-	Usage: ./node_modules/.bin/k ( k-expr | -k k-file) [ json-file ]
+	Usage: ./node_modules/.bin/k ( k-expr | -k k-file) [ -1 ] [ json-file ]
 	       E.g., cat '{"a": 10}' | ./node_modules/.bin/k '[(),()]'
 
 ### Examples
@@ -120,7 +138,7 @@ run the language from command line.
 2. By providing only `k`-expression, the script will compile the
    `k`-expression and apply the generated function to the `stdin`, line by line:
 
-		$ ./k.coffee '<["x=",.x," & y=",.y],["only x=",.x],["only y=",.y],["no x nor y"]>{CONCAT "x&y"}' 
+		$ ./node_modules/.bin/k '<["x=",.x," & y=",.y],["only x=",.x],["only y=",.y],["no x nor y"]>{CONCAT "x&y"}' 
 		
 		{"y": 123, "x": 432,"others": "..."}  --> {"x&y":"x=432 & y=123"} 
 		{"x":987}                             --> {"x&y":"only x=987"} 
@@ -146,11 +164,11 @@ run the language from command line.
 		 
 	We can use it by:
 	
-		$ ./k.coffee -k test.k
+		$ ./node_modules/.bin/k -k test.k
 	
 	If we want to read `json` objects from a file, e.g., `my-objects.json`, we do
 	
-		$ ./k.coffee -k test.k my-objects.json
+		$ ./node_modules/.bin/k -k test.k my-objects.json
 		{"x&y":"x=432 & y=123"} 
 		{"x&y":"onlyx=987"} 
 		{"x&y":"no x nor y"}
@@ -166,52 +184,62 @@ run the language from command line.
 		 ####################################################
 		
 # Using from `javascript`
-    
-    var k = require("k");
+			
+		var k = require("k");
+
+		k_expression = '()';
+		k.run(k_expression,"ANYTHING...");
+		// RETURNS: "ANYTHING..."
+
+		k_expression = '{"ala" name, 23 age}';
+		k.run(k_expression,"ANYTHING...");
+		// RETURNS: {"name":"ala","age":23}
+
+		k_expression = '[.year, .age]';
+		k.run(k_expression,{"year":2002,"age":19});
+		// RETURNS: [2002,19]
 
-    var k_expression;
+		k_expression = '[(), ()]';
+		k.run(k_expression,"duplicate me");
+		// RETURNS: ["duplicate me","duplicate me"]
 
-    k_expression = '()';
-    k.run(t_expression,"ANYTHING...");
-    // RETURNS: "ANYTHING..."
+		k_expression = '[[[()]]]';
+		k.run(k_expression,"nesting");
+		// RETURNS: [[["nesting"]]]
 
-    k_expression = '{"ala" name, 23 age}';
-    k.run(k_expression,"ANYTHING...");
-    // RETURNS: {"name":"ala","age":23}
+		k_expression = '[[()]] {() nested, .0.0 val}';
+		k.run(k_expression,"nesting and accessing");
+		// RETURNS: {"nested":[["nesting and accessing"]],"val":"nesting and accessing"}
 
-    k_expression = '[.year, .age]';
-    k.run(k_expression,{"year":2002,"age":19});
-    // RETURNS: [2002,19]
+		k_expression = '0000';
+		k.run(k_expression,{"test":"parse integer"});
+		// RETURNS: 0
 
-    k_expression = '[(), ()]';
-    k.run(k_expression,"duplicate me");
-    // RETURNS: ["duplicate me","duplicate me"]
+		k_expression = '[.y,.x] PLUS';
+		k.run(k_expression,{"x":3,"y":4});
+		// RETURNS: 7
 
-    k_expression = '[[[()]]]';
-    k.run(k_expression,"nesting");
-    // RETURNS: [[["nesting"]]]
+		var k_fn = k.compile('{.name nom, <[.age, 18] GT .0, [.age, 12] GT "ado", "enfant"> age}');
 
-    k_expression = '[[()]] {() nested, .0.0 val}';
-    k.run(k_expression,"nesting and accessing")
-    // RETURNS: {"nested":[["nesting and accessing"]],"val":"nesting and accessing"}
+		k_fn({"age":23,"name":"Emily"});
+		// RETURNS: {"nom":"Emily","age":23}
 
-    k_expression = '0000';
-    k.run(k_expression,{"test":"parse integer"});
-    // RETURNS: 0
+		k_fn({"age":16,"name":"Katrina"});
+		// RETURNS: {"nom":"Katrina","age":"ado"}
 
-    k_expression = '[.y,.x] PLUS';
-    k.run(k_expression,{"x":3,"y":4});
-    // RETURNS: 7
+		k_fn({"age":2,"name":"Mark"});
+		// RETURNS: {"nom":"Mark","age":"enfant"}
 
-    k_expression = '{.name nom, <[.age, 18] GT .0, [.age, 12] GT "ado", "enfant"> age}';
+		var k_fn = k.compile('$t = < i: int, t: [ t ] > ; <$t, $int>');
 
-    var k_fn = k.compile(k_expression);
+		k_fn(1);
+		// RETURNS: 1
 
-    k_fn({"age":23,"name":"Emily"});
-    // RETURNS: {"nom":"Emily","age":23}
+		k_fn({"i":1});
+		// RETURNS: {"i":1}
 
-    k_fn({"age":16,"name":"Katrina"});
-    // RETURNS: {"nom":"Katrina","age":"ado"}
+		k_fn([{"i":2},{"i":3},{"t":[]}]);
+		// RETURNS: undefined
 
-    k_fn({"age":2,"name":"Mark"})
-    // RETURNS: {"nom":"Mark","age":"enfant"}
+		k_fn({"t":[{"i":2},{"i":3},{"t":[]}]});
+		// RETURNS: {"t":[{"i":2},{"i":3},{"t":[]}]}

package/bnat.k

@@ -71,7 +71,7 @@ _reverse_bnat =
 _add2wc =
 -- least significant bit first addition with carry
 --- :{ :bnat x, :bnat y, :[0,1] c}
-    -- _log_
+    -- _log!
     <
       {.x."0" x, .y."0" y, .c."0" c} {.x x, .y y, _ _0 c} _add2wc _0,
       {.x."0" x, .y."0" y, .c."1" c} {.x x, .y y, _ _0 c} _add2wc _1,

package/code.k

@@ -1,8 +1,9 @@
 inc = [(),1] PLUS;
-$tree = <leaf: string, tree: {left: tree, right: tree}>;
+max = <GT .0, .1>;  -- max = < SNOC [.0, .1 max] <GT .0, .1>, .0 >;
+$tree = < string leaf, {tree left, tree right} tree>;
 height =  $tree <
-    .leaf 0,
-    .tree [.left height, .right height] <GT .0, .1> inc
+  .leaf 0,
+  .tree [.left height, .right height] max inc
 > $int;
 
 <$tree, 
@@ -15,4 +16,4 @@ height =  $tree <
           }
     }
   }
-> _log_ height
+> _log! height

package/codes.coffee

@@ -0,0 +1,109 @@
+
+are_different = (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]
+          , {}
+      return true unless Object.keys(fields1).length is Object.keys(fields2).length
+      for field,rep of fields1 
+        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}
+
+compareAs = (fn) ->
+  (a,b) -> 
+    [a,b] = [a,b].map fn
+    return -1 if a < b
+    return 1 if a > b
+    0 
+
+pretty_labels = (label_ref_map, codes, representatives) ->
+  labels = Object.keys(label_ref_map)
+  .sort compareAs (x) -> x
+  .map (label) ->
+    "#{pretty {code:"ref",ref:label_ref_map[label]}, codes, representatives} #{label}"
+  .join ", "
+
+pretty = (codeExp, codes, representatives) ->
+  switch codeExp.code 
+    when "ref"
+      name = representatives[codeExp.ref] ? codeExp.ref
+      if name.startsWith ":"
+        pretty codes[name], codes, representatives
+      else
+        name
+    when "product"
+      "{#{pretty_labels codeExp.product, codes, representatives}}"
+    when "union"
+      "<#{pretty_labels codeExp.union, codes, representatives}>"
+    when "vector"
+      "[#{representatives[codeExp.ref] ? codeExp.ref}]"
+    else    
+      ":error"
+
+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]}
+  
+    normalized    
+  , {}
+
+module.exports = {minimize,pretty,normalize,normalizeAll}
+
+

package/codes.js

@@ -0,0 +1,176 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  var are_different, compareAs, minimize, normalize, normalizeAll, pretty, pretty_labels;
+
+  are_different = function(classes, representatives, name1, name2, codes) {
+    var arg1, arg2, code1, code2, field, fields1, fields2, rep;
+    if (name1 === name2) {
+      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;
+              return fields[label] = (ref = representatives[arg[label]]) != null ? ref : arg[label];
+            }, {});
+          })(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) {
+            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};
+  };
+
+  compareAs = function(fn) {
+    return function(a, b) {
+      [a, b] = [a, b].map(fn);
+      if (a < b) {
+        return -1;
+      }
+      if (a > b) {
+        return 1;
+      }
+      return 0;
+    };
+  };
+
+  pretty_labels = function(label_ref_map, codes, representatives) {
+    var labels;
+    return labels = Object.keys(label_ref_map).sort(compareAs(function(x) {
+      return x;
+    })).map(function(label) {
+      return `${pretty({
+        code: "ref",
+        ref: label_ref_map[label]
+      }, codes, representatives)} ${label}`;
+    }).join(", ");
+  };
+
+  pretty = function(codeExp, codes, representatives) {
+    var name, ref, ref1;
+    switch (codeExp.code) {
+      case "ref":
+        name = (ref = representatives[codeExp.ref]) != null ? ref : codeExp.ref;
+        if (name.startsWith(":")) {
+          return pretty(codes[name], codes, representatives);
+        } else {
+          return name;
+        }
+        break;
+      case "product":
+        return `{${pretty_labels(codeExp.product, codes, representatives)}}`;
+      case "union":
+        return `<${pretty_labels(codeExp.union, codes, representatives)}>`;
+      case "vector":
+        return `[${(ref1 = representatives[codeExp.ref]) != null ? ref1 : codeExp.ref}]`;
+      default:
+        return ":error";
+    }
+  };
+
+  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) {
+          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: representatives[code.vector]
+              };
+          }
+        })(codes[name]);
+      }
+      return normalized;
+    }, {});
+  };
+
+  module.exports = {minimize, pretty, normalize, normalizeAll};
+
+}).call(this);

package/fib.k

@@ -1,4 +1,4 @@
-fib_aux =
+fib_aux = _log!
   <
     { [.n, 1] GT [.0,-1] PLUS n,
       ."[fib(n),fib(n-1)" [[.0,.1] PLUS, .0] "[fib(n),fib(n-1)"

package/index.coffee

@@ -1,11 +1,25 @@
 fs = require "fs"
 {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) ->
-    run.defs = defs 
+    # 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"
 
 compile_file = (fileName) ->

package/index.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
 (function() {
-  var compile, compile_file, fs, parse, run, runScriptOnData;
+  var compile, compile_file, finalize, fs, parse, run, runScriptOnData, t;
 
   fs = require("fs");
 
@@ -8,9 +8,26 @@
 
   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}) {
-      run.defs = defs;
+      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);
       };

package/package.json

@@ -1,11 +1,12 @@
 {
     "name": "@fraczak/k",
-    "version": "1.1.0",
+    "version": "1.1.2",
     "description": "k-language for JSON-like data transformation",
     "main": "index.js",
     "scripts": {
         "prepare": "coffee -c symbol-table.coffee; jison parser.jison",
         "prepublishOnly": "coffee -c *.coffee; echo '#!/usr/bin/env node' | cat - k.js > k.sh",
+        "all": "npm run prepublishOnly; npm run prepare; npm run prepublishOnly",
         "test": "coffee -c symbol-table.coffee; jison parser.jison; coffee test.coffee"
     },
     "author": "Wojciech Fraczak",

package/parser.jison

@@ -44,27 +44,27 @@ str: STRING                             { $$ = String(yytext).slice(1,-1); };
 int: INT                                { $$ = parseInt(String(yytext)); };
 
 input_with_eof: defs comp EOF               {
-    result = {defs: $1, exp: $2};
+    result = {defs: {rels: s.rels, codes: s.codes}, exp: $2};
     // console.log(JSON.stringify(result, "", 2));
     return result;
 };
 
-defs:                                   { $$ = {codes: {}, rels: {}}; }
-    | defs name EQ comp SC              { $1.rels[$2] = $4; $$ = $1; }
-    | defs DOLLAR name EQ code SC       { $1.codes[$3] = $5; $$ = $1; }
+defs:                                   {  }
+    | defs name EQ comp SC              { s.add_rel($2,$4); }
+    | defs DOLLAR name EQ code SC       { s.add_code($3,$5); }
     ;
 
 code
     : name                              { $$ = {code: "ref", ref: $1}; }
     | LC labelled_codes RC              { $$ = {code: "product", 
                                                 product: $2.reduce((r, lc) => { 
-                                                  r[lc.label] = lc.code;
+                                                  r[lc.label] = s.as_ref(lc.code);
                                                   return r }
                                                 , {})}; }
-    | LB code RB                        { $$ = {code: "vector", vector: $2}; }
+    | LB code RB                        { $$ = {code: "vector", vector: s.as_ref($2)}; }
     | LA labelled_codes RA              { $$ = {code: "union", 
                                                 union: $2.reduce((r, lc) => { 
-                                                  r[lc.label] = lc.code;
+                                                  r[lc.label] = s.as_ref(lc.code);
                                                   return r }
                                                 , {})}; }
     ;
@@ -95,7 +95,7 @@ comp
 exp
     : LC labelled RC                    { $$ = $2; }
     | LB list RB                        { $$ = {op: "vector", vector: $2}; }
-    | LA list RA                        { $$ = {op: "union", union: $2}; }
+    | LA list RA                        { $$ = s.union($2); }
     | name                              { $$ = {op: "ref", ref: $1}; }
     | LP RP                             { $$ = s.identity;  }
     | LP comp RP                        { $$ = $2;  }
@@ -104,7 +104,7 @@ exp
     | DOT int                           { $$ = {op: "dot", dot: $2}; }
     | DOT str                           { $$ = {op: "dot", dot: $2}; }
     | DOT name                          { $$ = {op: "dot", dot: $2}; }
-    | DOLLAR code                       { $$ = {op: "code", code: $2}; }
+    | DOLLAR code                       { $$ = {op: "code", code: s.as_ref($2)}; }
     ;
 
 labelled

package/parser.js

@@ -94,19 +94,19 @@ case 3:
 break;
 case 4:
 
-    result = {defs: $$[$0-2], exp: $$[$0-1]};
+    result = {defs: {rels: s.rels, codes: s.codes}, exp: $$[$0-1]};
     // console.log(JSON.stringify(result, "", 2));
     return result;
 
 break;
 case 5:
- this.$ = {codes: {}, rels: {}}; 
+  
 break;
 case 6:
- $$[$0-4].rels[$$[$0-3]] = $$[$0-1]; this.$ = $$[$0-4]; 
+ s.add_rel($$[$0-3],$$[$0-1]); 
 break;
 case 7:
- $$[$0-5].codes[$$[$0-3]] = $$[$0-1]; this.$ = $$[$0-5]; 
+ s.add_code($$[$0-3],$$[$0-1]); 
 break;
 case 8:
  this.$ = {code: "ref", ref: $$[$0]}; 
@@ -114,17 +114,17 @@ break;
 case 9:
  this.$ = {code: "product", 
                                                 product: $$[$0-1].reduce((r, lc) => { 
-                                                  r[lc.label] = lc.code;
+                                                  r[lc.label] = s.as_ref(lc.code);
                                                   return r }
                                                 , {})}; 
 break;
 case 10:
- this.$ = {code: "vector", vector: $$[$0-1]}; 
+ this.$ = {code: "vector", vector: s.as_ref($$[$0-1])}; 
 break;
 case 11:
  this.$ = {code: "union", 
                                                 union: $$[$0-1].reduce((r, lc) => { 
-                                                  r[lc.label] = lc.code;
+                                                  r[lc.label] = s.as_ref(lc.code);
                                                   return r }
                                                 , {})}; 
 break;
@@ -156,7 +156,7 @@ case 23:
  this.$ = {op: "vector", vector: $$[$0-1]}; 
 break;
 case 24:
- this.$ = {op: "union", union: $$[$0-1]}; 
+ this.$ = s.union($$[$0-1]); 
 break;
 case 25:
  this.$ = {op: "ref", ref: $$[$0]}; 
@@ -177,7 +177,7 @@ case 30: case 31: case 32:
  this.$ = {op: "dot", dot: $$[$0]}; 
 break;
 case 33:
- this.$ = {op: "code", code: $$[$0]}; 
+ this.$ = {op: "code", code: s.as_ref($$[$0])}; 
 break;
 case 34:
  this.$ = {op: "product", product: []}; 

package/run.coffee

@@ -3,8 +3,8 @@ valid = (x) ->
   return x if x?
 
 builtin =
-  "_log_": (arg) ->
-    console.log "_log_: #{JSON.stringify arg}"
+  "_log!": (arg) ->
+    console.log "_log!: #{JSON.stringify arg}"
     arg
   "GT": (args) ->
     [ok,_] = do ([last,args...] = args) ->
@@ -48,11 +48,8 @@ codes =
     x is true or x is false
 
 verify = (code, value) ->
+  # console.log {code,value}
   switch code.code
-    when "ref"
-      do (c = run.defs.codes[code.ref]) ->
-        return verify c, value if c?  
-        codes[code.ref] value
     when "vector"
       value.every (x) ->
         verify code.vector, x
@@ -65,8 +62,13 @@ verify = (code, value) ->
       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
@@ -77,7 +79,7 @@ run = (exp, value) ->
       when "str", "int"
         return exp[exp.op]
       when "ref"
-        do (defn = run.defs.rels[exp.ref]) ->
+        do (defn = run.defs.rels[exp.ref]?[0]) ->
           if defn?
             run defn, value
           else  

package/run.js

@@ -13,8 +13,8 @@
   };
 
   builtin = {
-    "_log_": function(arg) {
-      console.log(`_log_: ${JSON.stringify(arg)}`);
+    "_log!": function(arg) {
+      console.log(`_log!: ${JSON.stringify(arg)}`);
       return arg;
     },
     "GT": function(args) {
@@ -111,14 +111,8 @@
   };
 
   verify = function(code, value) {
+    // console.log {code,value}
     switch (code.code) {
-      case "ref":
-        return (function(c) {
-          if (c != null) {
-            return verify(c, value);
-          }
-          return codes[code.ref](value);
-        })(run.defs.codes[code.ref]);
       case "vector":
         return value.every(function(x) {
           return verify(code.vector, x);
@@ -139,12 +133,20 @@
           }
           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 {
@@ -171,7 +173,7 @@
                 return value;
               })(builtin[exp.ref](value));
             }
-          })(run.defs.rels[exp.ref]);
+          })((ref = run.defs.rels[exp.ref]) != null ? ref[0] : void 0);
         case "dot":
           return value[exp.dot];
         case "comp":
@@ -192,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);

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/typed-fib.k

@@ -0,0 +1,19 @@
+inc = [(),1] PLUS;
+fib2 =
+$ { int target, int x, int "fib(x)", int "fib(x-1)" }
+  _log!
+  <
+    {[.target,.x] GT guard, () input}
+    .input
+    {.target target,
+     .x inc x,
+     [."fib(x)", ."fib(x-1)"] PLUS "fib(x)",
+     ."fib(x)" "fib(x-1)" }
+    fib2,
+    ."fib(x)"
+  >
+$ int;
+
+{() target, 0 x, 1 "fib(x)", 0 "fib(x-1)"} fib2
+ 
+