@fraczak/k 1.2.2 → 1.3.0

package/INTRO.md

@@ -0,0 +1,131 @@
+# k - the way of building and manipulating JSON-like data
+
+Technically: notation for defining __first-order partial functions__.
+
+An example of a _partial function_ is "`.toto`", which maps an object
+to its property named `toto`, or it is not defined if the property
+doesn't exist. E.g.,
+
+    .toto :
+        {"toto": 5, "titi": 10}  --> 5
+        {"titi": 10}             ... undefined // it is not a value!
+
+---
+
+## Combining "partial functions"
+
+There are three ways of combining functions:
+
+1. __composition__: `(f1 f2 ...)`, e.g. `(.toto .titi)` extracts
+   nested field.
+
+        (.toto .titi) :
+            {"toto": {"titi": 10}}   --> 10
+            {"toto": 10 }            ... undefined
+            {}                       ... undefined
+
+2. __merge__: `< f1, f2,... >`, e.g., `<.toto, .titi>` extracts field
+   `toto` if present; otherwise extracts `titi`.
+
+        <.toto, .titi> :
+            {"toto": 5, "titi": 10}  --> 5
+            {"titi": 10 }            --> 10
+            {}                       ... undefined
+
+3. __product__: `{ f1 label1, f2 label2, ...}`, e.g., `{.toto TOTO,
+   .titi TITI}` extracts two fields and builds a record out of them.
+
+        {.toto TOTO, .titi TITI} :
+            {"toto": 5, "titi": 10}  --> {"TOTO": 5, "TITI": 10}
+            {"titi": 10 }            ... undefined
+
+---
+
+__QUIZ__: What is:
+
+ - empty composition: `()` ?
+ - empty merge: `<>` ?
+ - empty product: `{}` ?
+ - `{{{{} s} s} s}` ?
+ - `({{{() a} b} c} .c .b .a)` ?
+
+---
+
+## Basic extensions
+
+### Constants, i.e., literals for `strings`, `integers`, `booleans`, and `null`
+
+A constant defines a function which ignores its argument and produces
+the constant value. E.g.:
+
+    {123 int, "kScript" str, true bool, null null} :
+        <any>  --> {"int":123,"str":"kScript","bool":true,"null":null}
+
+### Vector product
+
+Vector product can be used as an abbreviation for product whose field
+names are integers starting from zero. E.g., `{.toto "0", .titi "1",
+123 "2"}` can be written as `[.toto, .titi, 123]`.
+
+    [.toto, .titi, 12] :
+        {"toto": 5, "titi": 10 }  --> [5, 10, 12]  // {"0":5,"1":10,"2":12}
+
+    .1 :
+        ["A","B","C"]  --> "B"
+        ["a"]          ... undefined
+---
+
+## Pragmatic extensions, aka "standard library"
+
+- `GT` :
+
+        [4,3,0]   --> [4,3,0]
+        [5,8]     -   undefined
+
+- `EQ` :
+
+        [4,4,4]   --> [4,4,4]
+        [5,8]     -   undefined
+
+- `[PLUS, TIMES, MINUS]` :
+
+        [2,2,2] --> [6,8,-2]
+
+- `CONCAT` :
+
+        ["a","bc","d"] --> "abcd"
+
+- `toJSON` :
+
+        {a: 12} --> "{\"a\":12}"
+
+- `fromJSON` : 
+ 
+        "{\"a\":12}" --> {a: 12}
+
+- `DIV`, `FDIV`, `CONS`, `SNOC`, `_log!`
+
+---
+
+## Recursive definitions
+
+      -- factorial.k
+      dec = ([(),-1] PLUS);
+      zero? = ([(),0] EQ 0);
+      factorial = <
+        (zero? 1), 
+        ([(dec factorial), ()] TIMES)
+      >;
+      { () x, factorial "x!" }
+
+## Codes (_types_)
+
+_Codes_ (prefixed by `$`) can be defined by taged union and product. E.g.:
+
+      $nat = <nat s, {} z>;     -- e.g., {{{{} z} s} s}
+      $pair = {nat x, nat y};   -- e.g., {{{} z} x, {{{{} z} s} s} y}
+      
+      s = ($nat {() s} $nat);
+      add = ($pair <{(.x .s) x, (.y s) y} add, .y> $nat);
+
+

package/README.md

@@ -1,6 +1,6 @@
 # k-language
 
-    npm install @fraczak/k
+    npm install '@fraczak/k'
 
 From javascript:
 
@@ -72,20 +72,21 @@ the field (or a vector with the index).
 
 `k`-expression can be prefixed by function definitions. E.g.:
 
-    dec = [(),1] MINUS;
-    factorial = <
-      [(),1] EQ 1,
-      [dec factorial, ()] TIMES
-    >;
-    { () x, < factorial, "not defined" > "x!" }
+        dec = [(),-1] PLUS;
+        zero? = [(),0] EQ 0;
+        factorial = <
+          zero? 1, 
+          [dec factorial, ()] TIMES
+        >;
+        { () x, factorial "x!" }
 
 Another example could be finding the biggest (max) value in a vector:
 
     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]
+      <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
@@ -102,7 +103,7 @@ There are three predefined value encodings: `int`, `string`, and
 
 One can define recursive codes. E.g.:
 
-    $ tree = <string leaf, {tree left, tree right} tree>;
+    $tree = <string leaf, {tree left, tree right} tree>;
 
 Each _code_ definition starts with a `$`.
 The above example defines new code called _tree_.
@@ -143,8 +144,8 @@ run the language from command line.
         > ./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"} 
-         {"z":123}                             --> {"x&y":"no x nor y"}
+         {"x": 987}                            --> {"x&y":"only x=987"} 
+         {"z": 123}                            --> {"x&y":"no x nor y"}
          ^D - to interrupt
 
 3. If the `k`-expression is long, it can be put in a file, e.g.:
@@ -172,7 +173,7 @@ run the language from command line.
 
         > ./node_modules/.bin/k -k test.k my-objects.json
          {"x&y":"x=432 & y=123"} 
-         {"x&y":"onlyx=987"} 
+         {"x&y":"only x=987"} 
          {"x&y":"no x nor y"}
 
     where:
@@ -181,8 +182,8 @@ run the language from command line.
          ####################################################
          # empty lines and lines starting with # are ignored
          {"y": 123, "x": 432,"others": "..."}
-         {"x":987}
-         {"z":123}
+         {"x": 987}
+         {"z": 123}
          ####################################################
 
 ### k-REPL (Read-Evaluate-Print Loop)
@@ -194,7 +195,7 @@ shell for the language. E.g.:
      {'a' a, 'b' b} toJSON
      => "{\"a\":\"a\",\"b\":\"b\"}"
      {"a" a} toJSON fromJSON
-     => {"a":"a"}
+     => {"a": "a"}
      inc = [(),1] PLUS; 1 inc inc
      => 3
      inc inc inc inc

package/codes.coffee

@@ -53,37 +53,6 @@ minimize = (codes) ->
             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) ->
@@ -107,6 +76,6 @@ normalizeAll = (codes,representatives) ->
     normalized    
   , {}
 
-module.exports = {minimize,pretty,normalize,normalizeAll}
+module.exports = {minimize,normalize,normalizeAll}
 
 

package/codes.js

@@ -1,6 +1,6 @@
 // Generated by CoffeeScript 2.7.0
 (function() {
-  var are_different, compareAs, minimize, normalize, normalizeAll, pretty, pretty_labels;
+  var are_different, minimize, normalize, normalizeAll;
 
   are_different = function(classes, representatives, name1, name2, codes) {
     var arg1, arg2, code1, code2, field, fields1, fields2, rep;
@@ -92,53 +92,6 @@
     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) {
@@ -176,6 +129,6 @@
     }, {});
   };
 
-  module.exports = {minimize, pretty, normalize, normalizeAll};
+  module.exports = {minimize, normalize, normalizeAll};
 
 }).call(this);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "1.2.2",
+    "version": "1.3.0",
     "description": "k-language for JSON-like data transformation",
     "main": "index.js",
     "scripts": {

package/parser.jison

@@ -82,8 +82,10 @@ non_empty_labelled_codes
 code_label 
     : code name                         { $$ = {label: $2, code: $1}; }
     | code str                          { $$ = {label: $2, code: $1}; }
+    | code int                          { $$ = {label: $2, code: $1}; }
     | name COL code                     { $$ = {label: $1, code: $3}; }
     | str COL code                      { $$ = {label: $1, code: $3}; }
+    | int COL code                      { $$ = {label: $1, code: $3}; }
     ;
 
 comp 
@@ -121,8 +123,10 @@ non_empty_labelled
 comp_label
     : comp name  { $$ = {label: $2, exp: $1}; }
     | comp str   { $$ = {label: $2, exp: $1}; }
+    | comp int   { $$ = {label: $2, exp: $1}; }
     | name COL comp { $$ = {label: $1, exp: $3}; }
     | str COL comp { $$ = {label: $1, exp: $3}; }
+    | int COL comp { $$ = {label: $1, exp: $3}; }
     ;
 
 list

package/parser.js

@@ -72,12 +72,12 @@
   }
 */
 var parser = (function(){
-var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[4,6,8,15,18,21,23,32,34],$V1=[1,7],$V2=[1,15],$V3=[1,16],$V4=[1,8],$V5=[1,9],$V6=[1,10],$V7=[1,11],$V8=[1,14],$V9=[1,20],$Va=[4,6,8,12,15,18,21,23,32,34],$Vb=[2,26],$Vc=[1,25],$Vd=[1,26],$Ve=[1,27],$Vf=[4,6,8,12,14,15,18,20,21,22,23,24,27,32,33,34],$Vg=[2,43],$Vh=[2,29],$Vi=[2,8],$Vj=[2,13],$Vk=[20,27],$Vl=[22,24,27],$Vm=[20,24,27],$Vn=[2,39],$Vo=[2,40];
+var o=function(k,v,o,l){for(o=o||{},l=k.length;l--;o[k[l]]=v);return o},$V0=[4,6,8,15,18,21,23,32,34],$V1=[1,7],$V2=[1,15],$V3=[1,16],$V4=[1,8],$V5=[1,9],$V6=[1,10],$V7=[1,11],$V8=[1,14],$V9=[1,20],$Va=[4,6,8,12,15,18,21,23,32,34],$Vb=[2,28],$Vc=[1,25],$Vd=[1,26],$Ve=[1,27],$Vf=[4,6,8,12,14,15,18,20,21,22,23,24,27,32,33,34],$Vg=[2,47],$Vh=[2,31],$Vi=[2,32],$Vj=[4,6,8,12,14,15,18,20,21,22,23,24,27,28,32,33,34],$Vk=[2,8],$Vl=[2,13],$Vm=[20,27],$Vn=[22,24,27],$Vo=[20,24,27],$Vp=[2,41],$Vq=[2,42],$Vr=[2,43];
 var parser = {trace: function trace () { },
 yy: {},
 symbols_: {"error":2,"name":3,"NAME":4,"str":5,"STRING":6,"int":7,"INT":8,"input_with_eof":9,"defs":10,"comp":11,"EOF":12,"EQ":13,"SC":14,"DOLLAR":15,"codeDef":16,"code":17,"LC":18,"labelled_codes":19,"RC":20,"LB":21,"RB":22,"LA":23,"RA":24,"non_empty_labelled_codes":25,"code_label":26,"COMMA":27,"COL":28,"exp":29,"labelled":30,"list":31,"LP":32,"RP":33,"DOT":34,"non_empty_labelled":35,"comp_label":36,"non_empty_list":37,"$accept":0,"$end":1},
 terminals_: {2:"error",4:"NAME",6:"STRING",8:"INT",12:"EOF",13:"EQ",14:"SC",15:"DOLLAR",18:"LC",20:"RC",21:"LB",22:"RB",23:"LA",24:"RA",27:"COMMA",28:"COL",32:"LP",33:"RP",34:"DOT"},
-productions_: [0,[3,1],[5,1],[7,1],[9,3],[10,0],[10,5],[10,6],[17,1],[17,1],[16,3],[16,3],[16,3],[19,0],[19,1],[25,1],[25,3],[26,2],[26,2],[26,3],[26,3],[11,1],[11,2],[29,3],[29,3],[29,3],[29,1],[29,2],[29,3],[29,1],[29,1],[29,2],[29,2],[29,2],[29,2],[30,0],[30,1],[35,1],[35,3],[36,2],[36,2],[36,3],[36,3],[31,0],[31,1],[37,1],[37,3]],
+productions_: [0,[3,1],[5,1],[7,1],[9,3],[10,0],[10,5],[10,6],[17,1],[17,1],[16,3],[16,3],[16,3],[19,0],[19,1],[25,1],[25,3],[26,2],[26,2],[26,2],[26,3],[26,3],[26,3],[11,1],[11,2],[29,3],[29,3],[29,3],[29,1],[29,2],[29,3],[29,1],[29,1],[29,2],[29,2],[29,2],[29,2],[30,0],[30,1],[35,1],[35,3],[36,2],[36,2],[36,2],[36,3],[36,3],[36,3],[31,0],[31,1],[37,1],[37,3]],
 performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
 /* this == yyval */
 
@@ -111,7 +111,7 @@ break;
 case 8:
  this.$ = {code: "ref", ref: $$[$0]}; 
 break;
-case 9: case 21: case 36: case 44:
+case 9: case 23: case 38: case 48:
  this.$ = $$[$0]; 
 break;
 case 10:
@@ -132,72 +132,72 @@ case 14:
                                                   return r }
                                                 , {}); 
 break;
-case 15: case 45:
+case 15: case 49:
  this.$ = [$$[$0]]; 
 break;
-case 16: case 46:
+case 16: case 50:
  this.$ = [].concat($$[$0-2],$$[$0]); 
 break;
-case 17: case 18:
+case 17: case 18: case 19:
  this.$ = {label: $$[$0], code: $$[$0-1]}; 
 break;
-case 19: case 20:
+case 20: case 21: case 22:
  this.$ = {label: $$[$0-2], code: $$[$0]}; 
 break;
-case 22:
+case 24:
  this.$ = s.comp($$[$0-1], $$[$0]); 
 break;
-case 23:
+case 25:
  this.$ = $$[$0-1]; 
 break;
-case 24:
+case 26:
  this.$ = {op: "vector", vector: $$[$0-1]}; 
 break;
-case 25:
+case 27:
  this.$ = s.union($$[$0-1]); 
 break;
-case 26:
+case 28:
  this.$ = {op: "ref", ref: $$[$0]}; 
 break;
-case 27:
+case 29:
  this.$ = s.identity;  
 break;
-case 28:
+case 30:
  this.$ = $$[$0-1];  
 break;
-case 29:
+case 31:
  this.$ = {op: "str", str: $$[$0]}; 
 break;
-case 30:
+case 32:
  this.$ = {op: "int", int: $$[$0]}; 
 break;
-case 31: case 32: case 33:
+case 33: case 34: case 35:
  this.$ = {op: "dot", dot: $$[$0]}; 
 break;
-case 34:
+case 36:
  this.$ = {op: "code", code: s.as_ref($$[$0])}; 
 break;
-case 35:
+case 37:
  this.$ = {op: "product", product: []}; 
 break;
-case 37:
+case 39:
  this.$ = {op: "product", product: [$$[$0]]}; 
 break;
-case 38:
+case 40:
  $$[$0-2].product = [].concat($$[$0-2].product,$$[$0]); this.$ = $$[$0-2]; 
 break;
-case 39: case 40:
+case 41: case 42: case 43:
  this.$ = {label: $$[$0], exp: $$[$0-1]}; 
 break;
-case 41: case 42:
+case 44: case 45: case 46:
  this.$ = {label: $$[$0-2], exp: $$[$0]}; 
 break;
-case 43:
+case 47:
  this.$ = []; 
 break;
 }
 },
-table: [o($V0,[2,5],{9:1,10:2}),{1:[3]},{3:4,4:$V1,5:12,6:$V2,7:13,8:$V3,11:3,15:[1,5],18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,12:[1,17],15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,34:$V8},o($Va,$Vb,{13:[1,21]}),{3:22,4:$V1,16:24,17:23,18:$Vc,21:$Vd,23:$Ve},o($Vf,[2,21]),o([4,6,8,12,13,14,15,18,20,21,22,23,24,27,28,32,33,34],[2,1]),{3:32,4:$V1,5:33,6:$V2,7:13,8:$V3,11:31,15:$V9,18:$V4,20:[2,35],21:$V5,23:$V6,29:6,30:28,32:$V7,34:$V8,35:29,36:30},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:36,15:$V9,18:$V4,21:$V5,22:$Vg,23:$V6,29:6,31:34,32:$V7,34:$V8,37:35},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:36,15:$V9,18:$V4,21:$V5,23:$V6,24:$Vg,29:6,31:37,32:$V7,34:$V8,37:35},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:39,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,33:[1,38],34:$V8},o($Vf,$Vh),o($Vf,[2,30]),{3:42,4:$V1,5:41,6:$V2,7:40,8:$V3},o([4,6,8,12,14,15,18,20,21,22,23,24,27,28,32,33,34],[2,2]),o($Vf,[2,3]),{1:[2,4]},o($Vf,[2,22]),o($Vf,$Vb),{3:43,4:$V1,16:24,17:23,18:$Vc,21:$Vd,23:$Ve},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:44,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},o($Va,$Vi,{13:[1,45]}),o($Vf,[2,34]),o($Vf,[2,9]),{3:50,4:$V1,5:51,6:$V2,16:24,17:49,18:$Vc,19:46,20:$Vj,21:$Vd,23:$Ve,25:47,26:48},{3:43,4:$V1,16:24,17:52,18:$Vc,21:$Vd,23:$Ve},{3:50,4:$V1,5:51,6:$V2,16:24,17:49,18:$Vc,19:53,21:$Vd,23:$Ve,24:$Vj,25:47,26:48},{20:[1,54]},{20:[2,36],27:[1,55]},o($Vk,[2,37]),{3:56,4:$V1,5:57,6:$V2,7:13,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,34:$V8},o($V0,$Vb,{28:[1,58]}),o($V0,$Vh,{28:[1,59]}),{22:[1,60]},o([22,24],[2,44],{27:[1,61]}),o($Vl,[2,45],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),{24:[1,62]},o($Vf,[2,27]),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,33:[1,63],34:$V8},o($Vf,[2,31]),o($Vf,[2,32]),o($Vf,[2,33]),o($Vf,$Vi),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,14:[1,64],15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,34:$V8},{16:65,18:$Vc,21:$Vd,23:$Ve},{20:[1,66]},o([20,24],[2,14],{27:[1,67]}),o($Vm,[2,15]),{3:68,4:$V1,5:69,6:$V2},o([4,6],$Vi,{28:[1,70]}),{28:[1,71]},{22:[1,72]},{24:[1,73]},o($Vf,[2,23]),{3:32,4:$V1,5:33,6:$V2,7:13,8:$V3,11:31,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,36:74},o($V0,$Vb,{20:$Vn,27:$Vn}),o($V0,$Vh,{20:$Vo,27:$Vo}),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:75,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:76,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},o($Vf,[2,24]),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:77,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},o($Vf,[2,25]),o($Vf,[2,28]),o($V0,[2,6]),{14:[1,78]},o($Vf,[2,10]),{3:50,4:$V1,5:51,6:$V2,16:24,17:49,18:$Vc,21:$Vd,23:$Ve,26:79},o($Vm,[2,17]),o($Vm,[2,18]),{3:43,4:$V1,16:24,17:80,18:$Vc,21:$Vd,23:$Ve},{3:43,4:$V1,16:24,17:81,18:$Vc,21:$Vd,23:$Ve},o($Vf,[2,11]),o($Vf,[2,12]),o($Vk,[2,38]),o($Vk,[2,41],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($Vk,[2,42],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($Vl,[2,46],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($V0,[2,7]),o($Vm,[2,16]),o($Vm,[2,19]),o($Vm,[2,20])],
+table: [o($V0,[2,5],{9:1,10:2}),{1:[3]},{3:4,4:$V1,5:12,6:$V2,7:13,8:$V3,11:3,15:[1,5],18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,12:[1,17],15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,34:$V8},o($Va,$Vb,{13:[1,21]}),{3:22,4:$V1,16:24,17:23,18:$Vc,21:$Vd,23:$Ve},o($Vf,[2,23]),o([4,6,8,12,13,14,15,18,20,21,22,23,24,27,28,32,33,34],[2,1]),{3:32,4:$V1,5:33,6:$V2,7:34,8:$V3,11:31,15:$V9,18:$V4,20:[2,37],21:$V5,23:$V6,29:6,30:28,32:$V7,34:$V8,35:29,36:30},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:37,15:$V9,18:$V4,21:$V5,22:$Vg,23:$V6,29:6,31:35,32:$V7,34:$V8,37:36},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:37,15:$V9,18:$V4,21:$V5,23:$V6,24:$Vg,29:6,31:38,32:$V7,34:$V8,37:36},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:40,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,33:[1,39],34:$V8},o($Vf,$Vh),o($Vf,$Vi),{3:43,4:$V1,5:42,6:$V2,7:41,8:$V3},o($Vj,[2,2]),o($Vj,[2,3]),{1:[2,4]},o($Vf,[2,24]),o($Vf,$Vb),{3:44,4:$V1,16:24,17:23,18:$Vc,21:$Vd,23:$Ve},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:45,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},o($Va,$Vk,{13:[1,46]}),o($Vf,[2,36]),o($Vf,[2,9]),{3:51,4:$V1,5:52,6:$V2,7:53,8:$V3,16:24,17:50,18:$Vc,19:47,20:$Vl,21:$Vd,23:$Ve,25:48,26:49},{3:44,4:$V1,16:24,17:54,18:$Vc,21:$Vd,23:$Ve},{3:51,4:$V1,5:52,6:$V2,7:53,8:$V3,16:24,17:50,18:$Vc,19:55,21:$Vd,23:$Ve,24:$Vl,25:48,26:49},{20:[1,56]},{20:[2,38],27:[1,57]},o($Vm,[2,39]),{3:58,4:$V1,5:59,6:$V2,7:60,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,34:$V8},o($V0,$Vb,{28:[1,61]}),o($V0,$Vh,{28:[1,62]}),o($V0,$Vi,{28:[1,63]}),{22:[1,64]},o([22,24],[2,48],{27:[1,65]}),o($Vn,[2,49],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),{24:[1,66]},o($Vf,[2,29]),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,33:[1,67],34:$V8},o($Vf,[2,33]),o($Vf,[2,34]),o($Vf,[2,35]),o($Vf,$Vk),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,14:[1,68],15:$V9,18:$V4,21:$V5,23:$V6,29:18,32:$V7,34:$V8},{16:69,18:$Vc,21:$Vd,23:$Ve},{20:[1,70]},o([20,24],[2,14],{27:[1,71]}),o($Vo,[2,15]),{3:72,4:$V1,5:73,6:$V2,7:74,8:$V3},o([4,6,8],$Vk,{28:[1,75]}),{28:[1,76]},{28:[1,77]},{22:[1,78]},{24:[1,79]},o($Vf,[2,25]),{3:32,4:$V1,5:33,6:$V2,7:34,8:$V3,11:31,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,36:80},o($V0,$Vb,{20:$Vp,27:$Vp}),o($V0,$Vh,{20:$Vq,27:$Vq}),o($V0,$Vi,{20:$Vr,27:$Vr}),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:81,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:82,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:83,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},o($Vf,[2,26]),{3:19,4:$V1,5:12,6:$V2,7:13,8:$V3,11:84,15:$V9,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8},o($Vf,[2,27]),o($Vf,[2,30]),o($V0,[2,6]),{14:[1,85]},o($Vf,[2,10]),{3:51,4:$V1,5:52,6:$V2,7:53,8:$V3,16:24,17:50,18:$Vc,21:$Vd,23:$Ve,26:86},o($Vo,[2,17]),o($Vo,[2,18]),o($Vo,[2,19]),{3:44,4:$V1,16:24,17:87,18:$Vc,21:$Vd,23:$Ve},{3:44,4:$V1,16:24,17:88,18:$Vc,21:$Vd,23:$Ve},{3:44,4:$V1,16:24,17:89,18:$Vc,21:$Vd,23:$Ve},o($Vf,[2,11]),o($Vf,[2,12]),o($Vm,[2,40]),o($Vm,[2,44],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($Vm,[2,45],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($Vm,[2,46],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($Vn,[2,50],{5:12,7:13,29:18,3:19,4:$V1,6:$V2,8:$V3,15:$V9,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8}),o($V0,[2,7]),o($Vo,[2,16]),o($Vo,[2,20]),o($Vo,[2,21]),o($Vo,[2,22])],
 defaultActions: {17:[2,4]},
 parseError: function parseError (str, hash) {
     if (hash.recoverable) {

package/pretty.coffee

@@ -0,0 +1,74 @@
+
+compareAs = (fn) ->
+  (a,b) -> 
+    [a,b] = [a,b].map fn
+    return -1 if a < b
+    return 1 if a > b
+    0 
+
+nameRE = /^[a-zA-Z_][a-zA-Z0-9_?!]*$/
+prettyCode_labels = ( codes, representatives, label_ref_map) ->
+  labels = Object.keys(label_ref_map)
+  .sort compareAs (x) -> x
+  .map (label) ->
+    plabel = if /^[a-zA-Z_][a-zA-Z0-9_?!]*$/.test label
+      label
+    else    
+      "'#{label}'" 
+    "#{prettyCode codes, representatives, {code:"ref",ref:label_ref_map[label]}} #{plabel}"
+  .join ", "
+
+prettyCode = (codes, representatives, codeExp) ->
+  switch codeExp.code 
+    when "ref"
+      name = representatives[codeExp.ref] ? codeExp.ref
+      if name.startsWith ":"
+        prettyCode codes, representatives, codes[name]
+      else
+        name
+    when "product"
+      "{#{prettyCode_labels codes, representatives, codeExp.product}}"
+    when "union"
+      "<#{prettyCode_labels codes, representatives, codeExp.union}>"
+    when "vector"
+      "[#{representatives[codeExp.vector] ? codeExp.vector}]"
+    else    
+      ":error"
+
+prettyRel = (prettyCode, exp) ->
+  "use strict"
+  pretty = (exp) ->
+    switch exp.op 
+      when 'vector' 
+        "[#{exp.vector.map(pretty).join(", ")}]"
+      when 'union'
+        "<#{exp.union.map(pretty).join(", ")}>"
+      when 'ref'
+        exp.ref
+      when 'identity'
+        "()"
+      when 'comp'
+        exp.comp.map(pretty).join(" ")
+      when 'str'
+        "'#{exp.str}'"
+      when 'int'
+        exp.int
+      when 'dot'
+        if 'number' is typeof exp.dot
+          ".#{exp.dot}"
+        else if nameRE.test exp.dot
+          ".#{exp.dot}"
+        else    
+          "'#{exp.dot}'"
+      when 'code'
+        "$#{prettyCode {code:"ref",ref:exp.code}}"
+      when 'product'
+        do (labelled = exp.product.map ({label,exp}) ->
+              if /^[a-zA-Z_][a-zA-Z0-9_?!]*$/.test label
+                  "#{pretty exp} #{label}"
+              else    
+                  "#{pretty exp} '#{label}'") ->
+          "{#{labelled.join(", ")}}"
+  pretty exp
+        
+module.exports = { prettyCode, prettyRel }

package/pretty.js

@@ -0,0 +1,106 @@
+// Generated by CoffeeScript 2.7.0
+(function() {
+  var compareAs, nameRE, prettyCode, prettyCode_labels, prettyRel;
+
+  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;
+    };
+  };
+
+  nameRE = /^[a-zA-Z_][a-zA-Z0-9_?!]*$/;
+
+  prettyCode_labels = function(codes, representatives, label_ref_map) {
+    var labels;
+    return labels = Object.keys(label_ref_map).sort(compareAs(function(x) {
+      return x;
+    })).map(function(label) {
+      var plabel;
+      plabel = /^[a-zA-Z_][a-zA-Z0-9_?!]*$/.test(label) ? label : `'${label}'`;
+      return `${prettyCode(codes, representatives, {
+        code: "ref",
+        ref: label_ref_map[label]
+      })} ${plabel}`;
+    }).join(", ");
+  };
+
+  prettyCode = function(codes, representatives, codeExp) {
+    var name, ref, ref1;
+    switch (codeExp.code) {
+      case "ref":
+        name = (ref = representatives[codeExp.ref]) != null ? ref : codeExp.ref;
+        if (name.startsWith(":")) {
+          return prettyCode(codes, representatives, codes[name]);
+        } else {
+          return name;
+        }
+        break;
+      case "product":
+        return `{${prettyCode_labels(codes, representatives, codeExp.product)}}`;
+      case "union":
+        return `<${prettyCode_labels(codes, representatives, codeExp.union)}>`;
+      case "vector":
+        return `[${(ref1 = representatives[codeExp.vector]) != null ? ref1 : codeExp.vector}]`;
+      default:
+        return ":error";
+    }
+  };
+
+  prettyRel = function(prettyCode, exp) {
+    "use strict";
+    var pretty;
+    pretty = function(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 (/^[a-zA-Z_][a-zA-Z0-9_?!]*$/.test(label)) {
+              return `${pretty(exp)} ${label}`;
+            } else {
+              return `${pretty(exp)} '${label}'`;
+            }
+          }));
+      }
+    };
+    return pretty(exp);
+  };
+
+  module.exports = {prettyCode, prettyRel};
+
+}).call(this);