@fraczak/k 2.0.1 → 2.1.0

package/README.md

@@ -94,6 +94,27 @@ the constant value. E.g.:
     {123 int, "kScript" str, true bool, null null} :
         "any"  --> {"int":123,"str":"kScript","bool":true,"null":null}
 
+Those values, i.e., `strings`, `integers`, `booleans`, and `null`, admit the
+projection to the canonicat string representation of the value, e.g.:
+
+    .2 :
+        2      --> {}
+        "2"    --> {}
+        4      ... undefined
+        true   ... undefined
+    
+    .true :
+        true   --> {}
+        "true" --> {}
+        4      ... undefined
+        "toto" ... undefined
+
+    .null :
+        null   --> {}
+        "null" --> {}
+        4      ... undefined
+        false  ... undefined
+
 #### Vector product
 
 Vector product can be seen as an abbreviation for product whose field
@@ -111,51 +132,57 @@ can be written as `[.toto, .titi, 123]`.
 
 ### Pragmatic extensions, aka "standard library"
 
-- `GT` : -- identity for lists of decreasing elements; undefined otherwise
+- `GT` -- identity for lists of decreasing elements; undefined otherwise
 
+      GT:
         [4,3]     --> [4,3]
         [3,4]     ... undefined
         []        --> []
         [4,3,0]   --> [4,3,0]
 
-- `EQ` : -- identity for lists of equal elements; undefined otherwise
+- `EQ` -- identity for lists of equal elements; undefined otherwise
 
+      EQ:     
         [4,4]     --> [4,4]
         [4,5]     ... undefined
         [4,4,4]   --> [4,4,4]
         []        --> []
 
-- `{PLUS plus, TIMES times}` :
+- `PLUS` and `TIMES` -- sum and product of lists of numbers
 
+      {PLUS plus, TIMES times} :
         [1,2]     --> {"plus":3,"times":2}
         [2,2,2]   --> {"plus":6,"times":8}
         []        --> {"plus":0,"times":1}
 
-- `CONCAT` :
+- `CONCAT` -- concatenation of lists of strings
 
+      CONCAT:
+        ["a","bc","d"] --> "abcd"
         ["a","bc","d"] --> "abcd"
 
-- `toJSON` :
+- `toJSON` and `fromJSON` -- conversion to and from JSON strings
 
+      toJSON:
         {"a": 12} --> "{\"a\":12}"
 
-- `fromJSON` :
+      fromJSON:   
+        "{\"a\":12}"       --> {"a":12}
+        "2.12"             --> 2.12
+        "[1,2.11,0.3e-32]" --> [1,2.11,3e-33]
 
-        "{\"a\":12}" --> {"a":12}
 
 - other predefined parial functions are: `DIV`, `FDIV`, `CONS`, `SNOC`, `toDateMsec`,
   `toDateStr`, and `_log!`.
 
 ---
 
-### Function definitions
+### Function and code (i.e., _type_) definitions
 
       dec = [(),-1] PLUS;
       max = <SNOC [.0, .1 max] <GT.0, .1>, .0> ;
       factorial = < [(),0] GT .0 [dec factorial, ()] TIMES, 1 >;
 
-### Codes (_types_)
-
 _Codes_ (prefixed by `$`) can be defined by taged union and product. E.g.:
 
       $nat = <nat 1, {} 0>;
@@ -178,6 +205,44 @@ by `[ codeExp ]`. All members of the vector are the same code. E.g.,
                                           -- of integers and a vector of strings
 ---
 
+### List comprehension on vectors
+
+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", 
+i.e., turn into a regular vector using `CARET` (`^`) operator. E.g.:
+
+```k
+    | .x  ^ :
+       [{x:12}, {x:8,y:10}, {y:98}]       -->  [12,8]
+       [1,2,3]                            -->  []
+```
+
+The PIPE operator can be used, e.g., to define a Cartesian product:
+
+```k
+    [.0 |, .1 |] ^ :
+        [[1,2], [3,4]]    -->  [[1,3],[1,4],[2,3],[2,4]]
+```
+
+or
+
+```k
+    { | x, | y } ^ :
+        [1,2]             --> [{"x":1,"y":1},{"x":2,"y":1},{"x":1,"y":2},{"x":2,"y":2}]
+```
+
+**QUIZ**: Write a function which will take a list of integers and an integer `x`, and count how many
+times value `x` appears in the list. (see `Examples/list-comprehension.k` for a solution)
+  
+```k
+    count_occurrences =
+    $ { [int] list, int x } 
+      -- ???
+    $ int;        
+```
+
+---
+
 ## Examples
 
 1. projection:
@@ -269,11 +334,11 @@ within `k`-expression is again prefixed by `$`.
 
 ## `k` (a command-line JSON processor using `k` syntax)
 
-There is a wrapper, `./node_modules/.bin/k` , which makes it easy to
+There is a wrapper, `k` (`./node_modules/.bin/k`), which makes it easy to
 run the language from command line.
 
-    > ./node_modules/.bin/k
-    ... errors ...
+    > k
+       ... errors ...
     Usage: ./node_modules/.bin/k ( k-expr | -k k-file) [ -1 ] [ json-file ]
     E.g., cat '{"a": 10}' | ./node_modules/.bin/k '[(),()]'
 
@@ -281,14 +346,14 @@ For example:
 
 1. One `k`-expression with one `json`-object:
 
-        > echo '{"x": 12, "y": 13}' | ./k.coffee '{ <.x, "no x"> x, () input}' 
+        > echo '{"x": 12, "y": 13}' | k '{ <.x, "no x"> x, () input}' 
          {"x":12,"input":{"x":12,"y":13}}
 
 2. By providing only `k`-expression, the script will compile the
    `k`-expression and apply the generated function to the `stdin`,
    line by line:
 
-        > ./node_modules/.bin/k '<["x=",.x," & y=",.y],["only x=",.x],["only y=",.y],["no x nor y"]>{CONCAT "x&y"}' 
+        > 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"} 
@@ -316,11 +381,11 @@ For example:
 
     We can use it by:
 
-        > ./node_modules/.bin/k -k test.k
+        > k -k test.k
 
     If we want to read `json` objects from a file, e.g., `my-objects.json`, we do
 
-        > ./node_modules/.bin/k -k test.k my-objects.json
+        > k -k test.k my-objects.json
          {"x&y":"x=432 & y=123"} 
          {"x&y":"only x=987"} 
          {"x&y":"no x nor y"}
@@ -340,11 +405,11 @@ For example:
 ### Short comparaison with `jq` tutorial examples: <https://stedolan.github.io/jq/tutorial/>
 
 1.
-        curl 'https://api.github.com/repos/stedolan/jq/commits?per_page=5' | jq '.'
-        curl 'https://api.github.com/repos/stedolan/jq/commits?per_page=5' | k  '()' -1 
+        curl 'https://api.github.com/repositories/5101141/commits?per_page=5' | jq '.'
+        curl 'https://api.github.com/repositories/5101141/commits?per_page=5' | k  '()' -1 
 2.
-        curl 'https://api.github.com/repos/stedolan/jq/commits?per_page=5' | jq '.[0]'
-        curl 'https://api.github.com/repos/stedolan/jq/commits?per_page=5' | k  '.0' -1 
+        curl 'https://api.github.com/repositories/5101141/commits?per_page=5' | jq '.[0]'
+        curl 'https://api.github.com/repositories/5101141/commits?per_page=5' | k  '.0' -1 
 3.
         jq '.[0] | {message: .commit.message, name: .commit.committer.name}'
         k '.0 {.commit.message message, .commit.committer.name name}' -1
@@ -352,21 +417,16 @@ For example:
    examples 4 and 5 of the `jq` tutorial are equivalent.
 5.
         jq '[.[] | {message: .commit.message, name: .commit.committer.name}]'
-        k 'f = .commit {.message message, .committer.name name}; %\
-           map_f = <SNOC [.0 f,.1 map_f] CONS, [.0 f], []>; %\
-           map_f' -1 
+        k '| .commit {.message message, .committer.name name} ^' -1 
 6.
         jq '[.[] | {message: .commit.message, name: .commit.committer.name, parents: [.parents[].html_url]}]'
-        k 'map_html_url = <SNOC [.0 .html_url, .1 map_html_url] CONS, [.0 .html_url], []>; %\
-           f = {.commit.message message, .commit.committer.name name, .parents map_html_url parents}; %\
-           map_f = <SNOC [.0 f, .1 map_f] CONS, [.0 f] , []>; %\
-           map_f' -1 
+        k '| {.commit.message message, .commit.committer.name name, .parents | .html_url ^ parents} ^' -1 
 
 ---
 
 ## k-REPL (Read-Evaluate-Print Loop)
 
-Also there is a REPL, `./node_modules/.bin/k-repl`, which acts like a toy
+Also there is a REPL, `k-repl` (`./node_modules/.bin/k-repl`), which acts like a toy
 shell for the language. E.g.:
 
     > ./node_modules/.bin/k-repl 

package/package.json

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

package/parser.jison

@@ -44,6 +44,8 @@ function fromEscString(escString) {
 ";"                                            return 'SC';
 ":"                                            return 'COL';
 "$"                                            return 'DOLLAR'; 
+"|"                                            return 'PIPE';
+"^"                                            return 'CARET';
 \"([^"\\]|\\(.|\n))*\"|\'([^'\\]|\\(.|\n))*\'  return 'STRING';
 [a-zA-Z_][a-zA-Z0-9_?!]*                       return 'NAME';
 0|[-]?[1-9][0-9]*                              return 'INT';
@@ -52,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
+%token LA LC LB LP RA RP RB RC EQ DOT COMMA SC COL DOLLAR PIPE CARET
 %token EOF
 
 %start input_with_eof
@@ -126,6 +128,8 @@ exp
     | DOT str                           { $$ = {op: "dot", dot: $2}; }
     | 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],$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 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 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,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]],
+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]],
 performAction: function anonymous(yytext, yyleng, yylineno, yy, yystate /* action[1] */, $$ /* vstack */, _$ /* lstack */) {
 /* this == yyval */
 
@@ -139,7 +139,7 @@ break;
 case 8:
  this.$ = {code: "ref", ref: $$[$0]}; 
 break;
-case 9: case 23: case 38: case 48:
+case 9: case 23: case 40: case 50:
  this.$ = $$[$0]; 
 break;
 case 10:
@@ -160,10 +160,10 @@ case 14:
                                                   return r }
                                                 , {}); 
 break;
-case 15: case 49:
+case 15: case 51:
  this.$ = [$$[$0]]; 
 break;
-case 16: case 50:
+case 16: case 52:
  this.$ = [].concat($$[$0-2],$$[$0]); 
 break;
 case 17: case 18: case 19:
@@ -206,27 +206,33 @@ case 36:
  this.$ = {op: "code", code: s.as_ref($$[$0])}; 
 break;
 case 37:
- this.$ = {op: "product", product: []}; 
+ this.$ = {op: "pipe"}; 
+break;
+case 38:
+ this.$ = {op: "caret"}; 
 break;
 case 39:
+ this.$ = {op: "product", product: []}; 
+break;
+case 41:
  this.$ = {op: "product", product: [$$[$0]]}; 
 break;
-case 40:
+case 42:
  $$[$0-2].product = [].concat($$[$0-2].product,$$[$0]); this.$ = $$[$0-2]; 
 break;
-case 41: case 42: case 43:
+case 43: case 44: case 45:
  this.$ = {label: $$[$0], exp: $$[$0-1]}; 
 break;
-case 44: case 45: case 46:
+case 46: case 47: case 48:
  this.$ = {label: $$[$0-2], exp: $$[$0]}; 
 break;
-case 47:
+case 49:
  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,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]},
+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]},
 parseError: function parseError (str, hash) {
     if (hash.recoverable) {
         this.trace(str);
@@ -734,18 +740,22 @@ case 15:return 28;
 break;
 case 16:return 15; 
 break;
-case 17:return 6;
+case 17:return 35;
+break;
+case 18:return 36;
+break;
+case 19:return 6;
 break;
-case 18:return 4;
+case 20:return 4;
 break;
-case 19:return 8;
+case 21:return 8;
 break;
-case 20:return 12;
+case 22:return 12;
 break;
 }
 },
-rules: [/^(?:[/][*]([*][^/]|[^*])*[*][/])/,/^(?:(\/\/|#|%|--)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:"([^"\\]|\\(.|\n))*"|'([^'\\]|\\(.|\n))*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:$)/],
-conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20],"inclusive":true}}
+rules: [/^(?:[/][*]([*][^/]|[^*])*[*][/])/,/^(?:(\/\/|#|%|--)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:\|)/,/^(?:\^)/,/^(?:"([^"\\]|\\(.|\n))*"|'([^'\\]|\\(.|\n))*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:$)/],
+conditions: {"INITIAL":{"rules":[0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22],"inclusive":true}}
 });
 return lexer;
 })();

package/pretty.mjs

@@ -34,9 +34,10 @@ function prettyCode (codes, representatives, codeExp) {
     case "product":
       return `{${prettyCode_labels(codes, representatives, codeExp.product)}}`;
     case "union":
-      return `<${prettyCode_labels(codes, representatives, codeExp.union)}>`;
+      return `< ${prettyCode_labels(codes, representatives, codeExp.union)} >`;
     case "vector":
-      return `[${representatives[codeExp.vector] || codeExp.vector}]`;
+      return `[${prettyCode(codes,representatives, {code:'ref', ref:codeExp.vector})}]`;
+      // return `[${representatives[codeExp.vector] || codeExp.vector}]`;
     default:
       return ":error";
   }

package/run.mjs

@@ -1,6 +1,16 @@
+import assert from "assert";
+
 const modulo = (a, b) => ((+a % (b = +b)) + b) % b;
 const valid = (x) => (isNaN(x) ? undefined : x);
 
+function isOpen(x) {
+  return (Array.isArray(x) && x.open);
+}
+
+function isClosed(x) {
+  return (Array.isArray(x) && !x.open);
+}
+  
 const builtin = {
   "_log!": (arg) => {
     console.error(`_log!: ${JSON.stringify(arg)}`);
@@ -83,12 +93,25 @@ function verify(code, value) {
 function run(exp, value) {
   "use strict";
   if (value === undefined) return;
+  if (isOpen(value)) {
+    if (exp.op === "caret") {
+      return [...value];
+    } else {
+      const result = [];
+      result.open = true
+      for (const v of value) {
+        const r = run(exp, v);
+        if (r !== undefined) result.push(r);
+      }
+      return result;
+    }
+  }
   switch (exp.op) {
     case "code":
       if (verify(exp.code, value)) {
         return value;
       }
-      break;
+      return;
     case "identity":
       return value;
     case "str":
@@ -99,25 +122,24 @@ function run(exp, value) {
       if (defn != null) {
         return run(defn[defn.length - 1], value);
       }
-      return builtin[exp.ref](value);
-    case "dot":
-      if (typeof value === "string") {
-        if (value == exp.dot) return {};
-        return;
+      const builtin_func = builtin[exp.ref];
+      if (builtin_func != null) {
+        return builtin_func(value);
       }
-      if (/^(0|([1-9]\d*))$/.test(value)) {
-        if (value == exp.dot) return {};
-        return;
-      } 
-      if (value === true) {
-        if (exp.dot == "true") return {};
-        return;
-      }
-      if (value === false) {
-        if (exp.dot == "false") return {};
+      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;
+    }
     case "comp":
       return exp.comp.reduce((value, exp) => {
         if (value !== undefined) return run(exp, value);
@@ -131,26 +153,85 @@ function run(exp, value) {
       }
       return;
     case "vector": {
-      const result = [];
+      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;
-        result.push(r);
+        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);
+          }
+        } 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);
+          }
+        }
       }
       return result;
     }
     case "product": {
-      const result = {};
+      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;
-        result[label] = r;
+        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]: 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});
+            }
+            result = newResult;
+          } else {
+            result[label] = r;
+          }
+        }      
       }
-      return result;
+      return result
     }
+    case "caret":
+      assert(false, "CARET (^): Only an 'open' vector can be closed.");  
     default:
-      return console.error(exp.op);
+      assert(false,`Unknown operation: '${exp.op}'`);
   }
 }