@fraczak/k 2.1.0 → 2.1.3

package/README.md

@@ -205,7 +205,7 @@ by `[ codeExp ]`. All members of the vector are the same code. E.g.,
                                           -- of integers and a vector of strings
 ---
 
-### List comprehension on vectors
+### List comprehension on vectors (experimental!)
 
 A vector can be "open" by PIPE (`|`) operator so the following partial function is applied to
 each element of the vector one by one, yielding another open value. An open value can be "closed", 
@@ -241,6 +241,15 @@ times value `x` appears in the list. (see `Examples/list-comprehension.k` for a
     $ int;        
 ```
 
+**WARNING**: The `CARET` operator makes composition not associative, i.e., if you use
+nested _list comprehension_ you cannot drop paranthesis anymore.
+E.g., `| (| PLUS ^ .0) ^` and `| | PLUS ^ .0 ^` are two different functions:
+
+```k
+   { |(| PLUS ^ .0) ^  x,  | | PLUS ^ .0 ^  y }:
+     [[[1,2],[3,4]],[[5,6],[7,8]]]   --> {"x":[3,11],"y":[3,7]}
+```
+
 ---
 
 ## Examples

package/package.json

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

package/parser.jison

@@ -54,7 +54,7 @@ function fromEscString(escString) {
 /lex
 
 %token NAME STRING INT
-%token LA LC LB LP RA RP RB RC EQ DOT COMMA SC COL DOLLAR PIPE CARET
+%token LA LC LB LP RA RP RB RC EQ DOT COMMA SC COL DOLLAR PIPE CARET 
 %token EOF
 
 %start input_with_eof
@@ -113,6 +113,7 @@ code_label
 comp 
     : exp                               { $$ = $1; }
     | comp exp                          { $$ = s.comp($1, $2); }
+    | comp CARET                        { $$ = {op: 'caret', caret: $1}; }
     ;
 
 exp
@@ -129,7 +130,6 @@ exp
     | DOT name                          { $$ = {op: "dot", dot: $2}; }
     | DOLLAR code                       { $$ = {op: "code", code: s.as_ref($2)}; }
     | PIPE                              { $$ = {op: "pipe"}; }
-    | CARET                             { $$ = {op: "caret"}; }
     ;
 
 labelled

package/parser.mjs

@@ -100,12 +100,12 @@ function fromEscString(escString) {
 
 
 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,35,36],$V1=[1,7],$V2=[1,17],$V3=[1,18],$V4=[1,8],$V5=[1,9],$V6=[1,10],$V7=[1,11],$V8=[1,14],$V9=[1,15],$Va=[1,16],$Vb=[1,22],$Vc=[4,6,8,12,15,18,21,23,32,34,35,36],$Vd=[2,28],$Ve=[1,27],$Vf=[1,28],$Vg=[1,29],$Vh=[4,6,8,12,14,15,18,20,21,22,23,24,27,32,33,34,35,36],$Vi=[2,49],$Vj=[2,31],$Vk=[2,32],$Vl=[4,6,8,12,14,15,18,20,21,22,23,24,27,28,32,33,34,35,36],$Vm=[2,8],$Vn=[2,13],$Vo=[20,27],$Vp=[22,24,27],$Vq=[20,24,27],$Vr=[2,43],$Vs=[2,44],$Vt=[2,45];
+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,33,35,36],$V1=[1,7],$V2=[1,16],$V3=[1,17],$V4=[1,8],$V5=[1,9],$V6=[1,10],$V7=[1,11],$V8=[1,14],$V9=[1,15],$Va=[1,22],$Vb=[1,20],$Vc=[4,6,8,12,15,18,21,23,30,33,35,36],$Vd=[2,29],$Ve=[1,27],$Vf=[1,28],$Vg=[1,29],$Vh=[4,6,8,12,14,15,18,20,21,22,23,24,27,30,33,34,35,36],$Vi=[2,49],$Vj=[2,32],$Vk=[2,33],$Vl=[4,6,8,12,14,15,18,20,21,22,23,24,27,28,30,33,34,35,36],$Vm=[2,8],$Vn=[2,13],$Vo=[20,27],$Vp=[4,6,8,15,18,21,23,30,33,35,36],$Vq=[22,24,27],$Vr=[20,24,27],$Vs=[2,43],$Vt=[2,44],$Vu=[2,45];
 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,"PIPE":35,"CARET":36,"non_empty_labelled":37,"comp_label":38,"non_empty_list":39,"$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",35:"PIPE",36:"CARET"},
-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],[29,1],[29,1],[30,0],[30,1],[37,1],[37,3],[38,2],[38,2],[38,2],[38,3],[38,3],[38,3],[31,0],[31,1],[39,1],[39,3]],
+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,"CARET":30,"labelled":31,"list":32,"LP":33,"RP":34,"DOT":35,"PIPE":36,"non_empty_labelled":37,"comp_label":38,"non_empty_list":39,"$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",30:"CARET",33:"LP",34:"RP",35:"DOT",36:"PIPE"},
+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],[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],[29,1],[31,0],[31,1],[37,1],[37,3],[38,2],[38,2],[38,2],[38,3],[38,3],[38,3],[32,0],[32,1],[39,1],[39,3]],
 performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
 /* this == yyval */
 
@@ -176,40 +176,40 @@ case 24:
  this.$ = s.comp($$[$0-1], $$[$0]); 
 break;
 case 25:
- this.$ = $$[$0-1]; 
+ this.$ = {op: 'caret', caret: $$[$0-1]}; 
 break;
 case 26:
- this.$ = {op: "vector", vector: $$[$0-1]}; 
+ this.$ = $$[$0-1]; 
 break;
 case 27:
- this.$ = s.union($$[$0-1]); 
+ this.$ = {op: "vector", vector: $$[$0-1]}; 
 break;
 case 28:
- this.$ = {op: "ref", ref: $$[$0]}; 
+ this.$ = s.union($$[$0-1]); 
 break;
 case 29:
- this.$ = s.identity;  
+ this.$ = {op: "ref", ref: $$[$0]}; 
 break;
 case 30:
- this.$ = $$[$0-1];  
+ this.$ = s.identity;  
 break;
 case 31:
- this.$ = {op: "str", str: $$[$0]}; 
+ this.$ = $$[$0-1];  
 break;
 case 32:
+ this.$ = {op: "str", str: $$[$0]}; 
+break;
+case 33:
  this.$ = {op: "int", int: $$[$0]}; 
 break;
-case 33: case 34: case 35:
+case 34: case 35: case 36:
  this.$ = {op: "dot", dot: $$[$0]}; 
 break;
-case 36:
- this.$ = {op: "code", code: s.as_ref($$[$0])}; 
-break;
 case 37:
- this.$ = {op: "pipe"}; 
+ this.$ = {op: "code", code: s.as_ref($$[$0])}; 
 break;
 case 38:
- this.$ = {op: "caret"}; 
+ this.$ = {op: "pipe"}; 
 break;
 case 39:
  this.$ = {op: "product", product: []}; 
@@ -231,8 +231,8 @@ case 49:
 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,35:$V9,36:$Va},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,12:[1,19],15:$Vb,18:$V4,21:$V5,23:$V6,29:20,32:$V7,34:$V8,35:$V9,36:$Va},o($Vc,$Vd,{13:[1,23]}),{3:24,4:$V1,16:26,17:25,18:$Ve,21:$Vf,23:$Vg},o($Vh,[2,23]),o([4,6,8,12,13,14,15,18,20,21,22,23,24,27,28,32,33,34,35,36],[2,1]),{3:34,4:$V1,5:35,6:$V2,7:36,8:$V3,11:33,15:$Vb,18:$V4,20:[2,39],21:$V5,23:$V6,29:6,30:30,32:$V7,34:$V8,35:$V9,36:$Va,37:31,38:32},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:39,15:$Vb,18:$V4,21:$V5,22:$Vi,23:$V6,29:6,31:37,32:$V7,34:$V8,35:$V9,36:$Va,39:38},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:39,15:$Vb,18:$V4,21:$V5,23:$V6,24:$Vi,29:6,31:40,32:$V7,34:$V8,35:$V9,36:$Va,39:38},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:42,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,33:[1,41],34:$V8,35:$V9,36:$Va},o($Vh,$Vj),o($Vh,$Vk),{3:45,4:$V1,5:44,6:$V2,7:43,8:$V3},o($Vh,[2,37]),o($Vh,[2,38]),o($Vl,[2,2]),o($Vl,[2,3]),{1:[2,4]},o($Vh,[2,24]),o($Vh,$Vd),{3:46,4:$V1,16:26,17:25,18:$Ve,21:$Vf,23:$Vg},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:47,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,35:$V9,36:$Va},o($Vc,$Vm,{13:[1,48]}),o($Vh,[2,36]),o($Vh,[2,9]),{3:53,4:$V1,5:54,6:$V2,7:55,8:$V3,16:26,17:52,18:$Ve,19:49,20:$Vn,21:$Vf,23:$Vg,25:50,26:51},{3:46,4:$V1,16:26,17:56,18:$Ve,21:$Vf,23:$Vg},{3:53,4:$V1,5:54,6:$V2,7:55,8:$V3,16:26,17:52,18:$Ve,19:57,21:$Vf,23:$Vg,24:$Vn,25:50,26:51},{20:[1,58]},{20:[2,40],27:[1,59]},o($Vo,[2,41]),{3:60,4:$V1,5:61,6:$V2,7:62,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,29:20,32:$V7,34:$V8,35:$V9,36:$Va},o($V0,$Vd,{28:[1,63]}),o($V0,$Vj,{28:[1,64]}),o($V0,$Vk,{28:[1,65]}),{22:[1,66]},o([22,24],[2,50],{27:[1,67]}),o($Vp,[2,51],{5:12,7:13,29:20,3:21,4:$V1,6:$V2,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8,35:$V9,36:$Va}),{24:[1,68]},o($Vh,[2,29]),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,29:20,32:$V7,33:[1,69],34:$V8,35:$V9,36:$Va},o($Vh,[2,33]),o($Vh,[2,34]),o($Vh,[2,35]),o($Vh,$Vm),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,14:[1,70],15:$Vb,18:$V4,21:$V5,23:$V6,29:20,32:$V7,34:$V8,35:$V9,36:$Va},{16:71,18:$Ve,21:$Vf,23:$Vg},{20:[1,72]},o([20,24],[2,14],{27:[1,73]}),o($Vq,[2,15]),{3:74,4:$V1,5:75,6:$V2,7:76,8:$V3},o([4,6,8],$Vm,{28:[1,77]}),{28:[1,78]},{28:[1,79]},{22:[1,80]},{24:[1,81]},o($Vh,[2,25]),{3:34,4:$V1,5:35,6:$V2,7:36,8:$V3,11:33,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,35:$V9,36:$Va,38:82},o($V0,$Vd,{20:$Vr,27:$Vr}),o($V0,$Vj,{20:$Vs,27:$Vs}),o($V0,$Vk,{20:$Vt,27:$Vt}),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:83,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,35:$V9,36:$Va},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:84,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,35:$V9,36:$Va},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:85,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,35:$V9,36:$Va},o($Vh,[2,26]),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:86,15:$Vb,18:$V4,21:$V5,23:$V6,29:6,32:$V7,34:$V8,35:$V9,36:$Va},o($Vh,[2,27]),o($Vh,[2,30]),o($V0,[2,6]),{14:[1,87]},o($Vh,[2,10]),{3:53,4:$V1,5:54,6:$V2,7:55,8:$V3,16:26,17:52,18:$Ve,21:$Vf,23:$Vg,26:88},o($Vq,[2,17]),o($Vq,[2,18]),o($Vq,[2,19]),{3:46,4:$V1,16:26,17:89,18:$Ve,21:$Vf,23:$Vg},{3:46,4:$V1,16:26,17:90,18:$Ve,21:$Vf,23:$Vg},{3:46,4:$V1,16:26,17:91,18:$Ve,21:$Vf,23:$Vg},o($Vh,[2,11]),o($Vh,[2,12]),o($Vo,[2,42]),o($Vo,[2,46],{5:12,7:13,29:20,3:21,4:$V1,6:$V2,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8,35:$V9,36:$Va}),o($Vo,[2,47],{5:12,7:13,29:20,3:21,4:$V1,6:$V2,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8,35:$V9,36:$Va}),o($Vo,[2,48],{5:12,7:13,29:20,3:21,4:$V1,6:$V2,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8,35:$V9,36:$Va}),o($Vp,[2,52],{5:12,7:13,29:20,3:21,4:$V1,6:$V2,8:$V3,15:$Vb,18:$V4,21:$V5,23:$V6,32:$V7,34:$V8,35:$V9,36:$Va}),o($V0,[2,7]),o($Vq,[2,16]),o($Vq,[2,20]),o($Vq,[2,21]),o($Vq,[2,22])],
-defaultActions: {19:[2,4]},
+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,33:$V7,35:$V8,36:$V9},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,12:[1,18],15:$Va,18:$V4,21:$V5,23:$V6,29:19,30:$Vb,33:$V7,35:$V8,36:$V9},o($Vc,$Vd,{13:[1,23]}),{3:24,4:$V1,16:26,17:25,18:$Ve,21:$Vf,23:$Vg},o($Vh,[2,23]),o([4,6,8,12,13,14,15,18,20,21,22,23,24,27,28,30,33,34,35,36],[2,1]),{3:34,4:$V1,5:35,6:$V2,7:36,8:$V3,11:33,15:$Va,18:$V4,20:[2,39],21:$V5,23:$V6,29:6,31:30,33:$V7,35:$V8,36:$V9,37:31,38:32},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:39,15:$Va,18:$V4,21:$V5,22:$Vi,23:$V6,29:6,32:37,33:$V7,35:$V8,36:$V9,39:38},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:39,15:$Va,18:$V4,21:$V5,23:$V6,24:$Vi,29:6,32:40,33:$V7,35:$V8,36:$V9,39:38},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:42,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,34:[1,41],35:$V8,36:$V9},o($Vh,$Vj),o($Vh,$Vk),{3:45,4:$V1,5:44,6:$V2,7:43,8:$V3},o($Vh,[2,38]),o($Vl,[2,2]),o($Vl,[2,3]),{1:[2,4]},o($Vh,[2,24]),o($Vh,[2,25]),o($Vh,$Vd),{3:46,4:$V1,16:26,17:25,18:$Ve,21:$Vf,23:$Vg},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:47,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,35:$V8,36:$V9},o($Vc,$Vm,{13:[1,48]}),o($Vh,[2,37]),o($Vh,[2,9]),{3:53,4:$V1,5:54,6:$V2,7:55,8:$V3,16:26,17:52,18:$Ve,19:49,20:$Vn,21:$Vf,23:$Vg,25:50,26:51},{3:46,4:$V1,16:26,17:56,18:$Ve,21:$Vf,23:$Vg},{3:53,4:$V1,5:54,6:$V2,7:55,8:$V3,16:26,17:52,18:$Ve,19:57,21:$Vf,23:$Vg,24:$Vn,25:50,26:51},{20:[1,58]},{20:[2,40],27:[1,59]},o($Vo,[2,41]),{3:60,4:$V1,5:61,6:$V2,7:62,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,29:19,30:$Vb,33:$V7,35:$V8,36:$V9},o($Vp,$Vd,{28:[1,63]}),o($Vp,$Vj,{28:[1,64]}),o($Vp,$Vk,{28:[1,65]}),{22:[1,66]},o([22,24],[2,50],{27:[1,67]}),o($Vq,[2,51],{5:12,7:13,29:19,3:21,4:$V1,6:$V2,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,30:$Vb,33:$V7,35:$V8,36:$V9}),{24:[1,68]},o($Vh,[2,30]),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,29:19,30:$Vb,33:$V7,34:[1,69],35:$V8,36:$V9},o($Vh,[2,34]),o($Vh,[2,35]),o($Vh,[2,36]),o($Vh,$Vm),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,14:[1,70],15:$Va,18:$V4,21:$V5,23:$V6,29:19,30:$Vb,33:$V7,35:$V8,36:$V9},{16:71,18:$Ve,21:$Vf,23:$Vg},{20:[1,72]},o([20,24],[2,14],{27:[1,73]}),o($Vr,[2,15]),{3:74,4:$V1,5:75,6:$V2,7:76,8:$V3},o([4,6,8],$Vm,{28:[1,77]}),{28:[1,78]},{28:[1,79]},{22:[1,80]},{24:[1,81]},o($Vh,[2,26]),{3:34,4:$V1,5:35,6:$V2,7:36,8:$V3,11:33,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,35:$V8,36:$V9,38:82},o($Vp,$Vd,{20:$Vs,27:$Vs}),o($Vp,$Vj,{20:$Vt,27:$Vt}),o($Vp,$Vk,{20:$Vu,27:$Vu}),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:83,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,35:$V8,36:$V9},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:84,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,35:$V8,36:$V9},{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:85,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,35:$V8,36:$V9},o($Vh,[2,27]),{3:21,4:$V1,5:12,6:$V2,7:13,8:$V3,11:86,15:$Va,18:$V4,21:$V5,23:$V6,29:6,33:$V7,35:$V8,36:$V9},o($Vh,[2,28]),o($Vh,[2,31]),o($V0,[2,6]),{14:[1,87]},o($Vh,[2,10]),{3:53,4:$V1,5:54,6:$V2,7:55,8:$V3,16:26,17:52,18:$Ve,21:$Vf,23:$Vg,26:88},o($Vr,[2,17]),o($Vr,[2,18]),o($Vr,[2,19]),{3:46,4:$V1,16:26,17:89,18:$Ve,21:$Vf,23:$Vg},{3:46,4:$V1,16:26,17:90,18:$Ve,21:$Vf,23:$Vg},{3:46,4:$V1,16:26,17:91,18:$Ve,21:$Vf,23:$Vg},o($Vh,[2,11]),o($Vh,[2,12]),o($Vo,[2,42]),o($Vo,[2,46],{5:12,7:13,29:19,3:21,4:$V1,6:$V2,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,30:$Vb,33:$V7,35:$V8,36:$V9}),o($Vo,[2,47],{5:12,7:13,29:19,3:21,4:$V1,6:$V2,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,30:$Vb,33:$V7,35:$V8,36:$V9}),o($Vo,[2,48],{5:12,7:13,29:19,3:21,4:$V1,6:$V2,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,30:$Vb,33:$V7,35:$V8,36:$V9}),o($Vq,[2,52],{5:12,7:13,29:19,3:21,4:$V1,6:$V2,8:$V3,15:$Va,18:$V4,21:$V5,23:$V6,30:$Vb,33:$V7,35:$V8,36:$V9}),o($V0,[2,7]),o($Vr,[2,16]),o($Vr,[2,20]),o($Vr,[2,21]),o($Vr,[2,22])],
+defaultActions: {18:[2,4]},
 parseError: function parseError (str, hash) {
     if (hash.recoverable) {
         this.trace(str);
@@ -718,7 +718,7 @@ case 4:return 18;
 break;
 case 5:return 21;
 break;
-case 6:return 32;
+case 6:return 33;
 break;
 case 7:return 24;
 break;
@@ -726,11 +726,11 @@ case 8:return 20;
 break;
 case 9:return 22;
 break;
-case 10:return 33;
+case 10:return 34;
 break;
 case 11:return 13; 
 break;
-case 12:return 34;
+case 12:return 35;
 break;
 case 13:return 27;
 break;
@@ -740,9 +740,9 @@ case 15:return 28;
 break;
 case 16:return 15; 
 break;
-case 17:return 35;
+case 17:return 36;
 break;
-case 18:return 36;
+case 18:return 30;
 break;
 case 19:return 6;
 break;

package/repl.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import k from "./index.mjs";
-import run from "./run.mjs";
+import {run, closeVector } from "./run.mjs";
 import { prettyCode, prettyRel } from "./pretty.mjs";
 
 import fs from "node:fs";
@@ -24,7 +24,7 @@ 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;
+    var e, file, first, i, kScript, last, len, line, ref, rest, todo;
     [first, ...rest] = data.toString("utf8").split("\n");
     buffer.push(first);
     if (rest.length > 0) {
@@ -32,81 +32,74 @@ const re = /^[ \n\t]*(?:--l[ ]+)(.+[^ ])[ ]*?$/;
       (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());
+          help();
+        } else if (line.match(/^[ \n\t]*\^$/)) {
+          val = closeVector(val); 
+          console.log(`=> ${JSON.stringify(val)}`);
         } 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)}`));
+          console.log(`=> ${JSON.stringify(val)}`);
         } else if (line.match(/^[ \n\t]*(?:--a)?$/)) {
-          results.push(console.log(JSON.stringify(run.defs, " ", 2)));
+          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, {})
-            )
-          );
+          (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
-                  );
-                }
+          console.log(
+            (function (defs, result) {
+              var codeExp, codeName, ref1;
+              if (defs == null) {
                 return result;
-              })(run.defs, {})
-            )
+              }
+              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)}`));
+            console.log(`=> ${JSON.stringify(val)}`);
           } catch (error) {
             e = error;
             console.error("ERROR:");
-            results.push(console.error(e));
+            console.error(e);
           }
-        } else {
-          results.push(void 0);
         }
       }
-      return results;
     }
   });
 })({}, []);

package/run.mjs

@@ -10,7 +10,23 @@ function isOpen(x) {
 function isClosed(x) {
   return (Array.isArray(x) && !x.open);
 }
-  
+
+Array.prototype.toJSON = function () {
+  if (this.open) {
+    // throw new Error(`Cannot serialize open vector: ${JSON.stringify([...this])}.`);
+    return {"OPEN VECTOR": [...this]};
+  }
+  return this;
+};
+
+function closeVector(val) {
+  if (isOpen(val)) {
+    return [...val];
+  }
+  console.error("Can close only an open vector.");
+  return val;
+}
+
 const builtin = {
   "_log!": (arg) => {
     console.error(`_log!: ${JSON.stringify(arg)}`);
@@ -43,7 +59,7 @@ const builtin = {
   null: () => null,
   toJSON: (x) => JSON.stringify(x),
   fromJSON: (x) => JSON.parse(x),
-  CONS: ([x, y]) => [x, ...y],
+  CONS: ([x, y]) => { try { return [x, ...y]; } catch (e) { return undefined; } },
   SNOC: (x) => (x.length > 1 ? [x[0], x.slice(1)] : undefined),
   toDateMsec: (x) => new Date(x).getTime(),
   toDateStr: (x) => new Date(x).toISOString(),
@@ -93,10 +109,9 @@ function verify(code, value) {
 function run(exp, value) {
   "use strict";
   if (value === undefined) return;
-  if (isOpen(value)) {
-    if (exp.op === "caret") {
-      return [...value];
-    } else {
+  while (true) {
+    if (isOpen(value)) {
+      if (exp.op === "caret2") return [...value];
       const result = [];
       result.open = true
       for (const v of value) {
@@ -105,135 +120,145 @@ function run(exp, value) {
       }
       return result;
     }
-  }
-  switch (exp.op) {
-    case "code":
-      if (verify(exp.code, value)) {
-        return value;
-      }
-      return;
-    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);
-      }
-      const builtin_func = builtin[exp.ref];
-      if (builtin_func != null) {
-        return builtin_func(value);
-      }
-      throw(`Unknown ref: '${exp.ref}'`);
-    case "dot":
-      // a hack to allow something like 'null . null' or '0 . 0' to work by returning unit
-      if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-        if (`${value}` === `${exp.dot}`) return {};
+    switch (exp.op) {
+      case "code":
+        if (verify(exp.code, value)) {
+          return value;
+        }
         return;
-      }
-      return value[exp.dot];
-    case "pipe": {
-      assert(isClosed(value), `PIPE (|): Only a regular vector value can be "open".`);
-      const result = [...value];
-      result.open = true;
-      return result;
-    }
-    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;
+      case "identity":
+        return value;
+      case "str":
+      case "int":
+        return exp[exp.op];
+      case "ref":
+        const defn = run.defs.rels[exp.ref];
+        if (defn != null) {
+          exp = defn[defn.length - 1];
+          continue;
+        }
+        const builtin_func = builtin[exp.ref];
+        if (builtin_func != null) {
+          return builtin_func(value);
+        }
+        throw(`Unknown ref: '${exp.ref}'`);
+      case "dot":
+        // a hack to allow something like 'null . null' or '0 . 0' to work by returning unit
+        if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+          if (`${value}` === `${exp.dot}`) return {};
+          return;
         }
+        return value[exp.dot];
+      case "pipe": {
+        assert(isClosed(value), `PIPE (|): Only a regular vector value can be "open".`);
+        const result = [...value];
+        result.open = true;
+        return result;
       }
-      return;
-    case "vector": {
-      let result = [];
-      let open = false;
-      for (let i = 0, len = exp.vector.length; i < len; i++) {
-        const r = run(exp.vector[i], value);
-        if (r === undefined) return;
-        if (open) {
-          if (isOpen(r)) {
-            const newResult = [];
-            newResult.open = true;
-            for (const x of result) {
-              for (const y of r) {
-                newResult.push([...x, y]);
+      case "comp":
+        for (let i = 0, len = exp.comp.length - 1; i < len; i++) {
+          const result = run(exp.comp[i], value);
+          if (result === undefined) return;
+          value = result;
+        }
+        exp = exp.comp[exp.comp.length - 1];
+        continue;
+      case "union":
+        for (let i = 0, len = exp.union.length -1; i < len; i++) {
+          const result = run(exp.union[i], value);
+          if (result !== undefined) {
+            return result;
+          }
+        }
+        exp = exp.union[exp.union.length - 1];
+        continue;
+      case "vector": {
+        let result = [];
+        let open = false;
+        for (let i = 0, len = exp.vector.length; i < len; i++) {
+          const r = run(exp.vector[i], value);
+          if (r === undefined) return;
+          if (open) {
+            if (isOpen(r)) {
+              const newResult = [];
+              newResult.open = true;
+              for (const x of result) {
+                for (const y of r) {
+                  newResult.push([...x, y]);
+                }
               }
+              result = newResult;
+            } else {
+              for (const x of result) x.push(r);
             }
-            result = newResult;
-          } else {
-            for (const x of result) x.push(r);
-          }
-        } else {
-          if (isOpen(r)) {
-            open = true;
-            const newResult = [];
-            newResult.open = true;
-            for (const x of r) {
-              newResult.push([...result, x]);
-            } 
-            result = newResult;
           } else {
-            result.push(r);
+            if (isOpen(r)) {
+              open = true;
+              const newResult = [];
+              newResult.open = true;
+              for (const x of r) {
+                newResult.push([...result, x]);
+              } 
+              result = newResult;
+            } else {
+              result.push(r);
+            }
           }
         }
+        return result;
       }
-      return result;
-    }
-    case "product": {
-      let result = {};
-      let open = false;
-      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;
-        if (open) {
-          if (isOpen(r)) {
-            let newResult = [];
-            newResult.open = true;
-            for (const v of r) {
+      case "product": {
+        let result = {};
+        let open = false;
+        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;
+          if (open) {
+            if (isOpen(r)) {
+              let newResult = [];
+              newResult.open = true;
+              for (const v of r) {
+                for (const x of result) {
+                  newResult.push({...x, [label]: v});
+                }
+              }
+              result = newResult;
+            } else {
+              let newResult = [];
+              newResult.open = true;
               for (const x of result) {
-                newResult.push({...x, [label]: v});
+                newResult.push({...x, [label]: r});
               }
-            }
-            result = newResult;
+              result = newResult;
+            } 
           } else {
-            let newResult = [];
-            newResult.open = true;
-            for (const x of result) {
-              newResult.push({...x, [label]: r});
-            }
-            result = newResult;
-          } 
-        } else {
-          if (isOpen(r)) {
-            open = true;
-            let newResult = [];
-            newResult.open = true;
-            for (const v of r.values()) {
-              newResult.push({...result, [label]: v});
+            if (isOpen(r)) {
+              open = true;
+              let newResult = [];
+              newResult.open = true;
+              for (const v of r.values()) {
+                newResult.push({...result, [label]: v});
+              }
+              result = newResult;
+            } else {
+              result[label] = r;
             }
-            result = newResult;
-          } else {
-            result[label] = r;
-          }
-        }      
+          }      
+        }
+        return result
       }
-      return result
+      case "caret": {
+        const result = run(exp.caret, value);
+        assert(isOpen(result), "CARET (^): Only an 'open' vector can be closed.");
+        return [...result];
+      }  
+      default:
+        assert(false,`Unknown operation: '${exp.op}'`);
+    
     }
-    case "caret":
-      assert(false, "CARET (^): Only an 'open' vector can be closed.");  
-    default:
-      assert(false,`Unknown operation: '${exp.op}'`);
-  }
+  };
 }
 
 export default run;
-export { run };
+export { run , closeVector };

package/symbol-table.mjs

@@ -57,21 +57,24 @@ function comp_first(e1, 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")
+  if (e1.op === "comp" && e2.op === "comp") {
     return {
       op: "comp",
       comp: [].concat(e1.comp, e2.comp),
     };
-  if (e1.op === "comp")
+  }
+  if (e1.op === "comp") {
     return {
       op: "comp",
       comp: [].concat(e1.comp, [e2]),
     };
-  if (e2.op === "comp")
+  }
+  if (e2.op === "comp") {
     return {
       op: "comp",
       comp: [].concat([e1], e2.comp),
     };
+  }
   return {
     op: "comp",
     comp: [e1, e2],