@fraczak/k 5.0.0 → 5.0.2

package/BIG_PICTURE.md

@@ -14,15 +14,18 @@ Formally, a _type_ is a (subclass of) finite tree automata. The type defines a s
 which corresponds to the set of trees accepted by the automaton.
 Therefore, every type admits a unique normal form in terms of its minimal deterministic tree automaton.
 
-The set of all types can be seen as the universal deterministic (infinite) tree automaton.
-Every node of that automaton defines a type; only a finite set of nodes are reachable from
-any node.
-
 Types are defined by two constructs:
 
 1. Product
 2. Union (also called tagged or disjoint union)
 
+```bnf
+type ::= name | '{' type_label_list '}' | '<' type_label_list '>'
+type_label_list ::= /* empty */ | ( type label ',' )* type label 
+name ::= IDENTIFIER
+label ::= STRING
+```
+
 Given a finite (possibly empty) set of types `t1, t2, ..., tn` and a set of pairwise different tags (labels) `l1, l2, ..., ln`,
 
 - by `{ t1 l1, t2 l2, ..., tn ln }`, we define a _product type_ with exactly `n`
@@ -43,8 +46,34 @@ Some properties of these types:
    singleton union types in the syntax of the language. The other benefit is that we will be able to use the same syntax
    for writing out values of both product and union types, interpretting every singleton product-like value, e.g., `{ a_value label }`,
    as a union type value (a variant).  
-2. The empty product type `{}` has a single value, called the _unit_ and also denoted by `{}`, which has no fields.
-3. The empty union type `<>` has no values.
+2. The empty product type, `{}`, has a single value, called the _unit_
+   and also denoted by `{}`, which has no fields.
+3. The empty union type, `<>`, has no values.
+
+### Filters (patterns)
+
+A _filter_ is a way of representing a _type class_, i.e, a set of types sharing some struture.
+For example, if I wanted to refer to all product types that have a field `f` of type `T`,
+I would write a pattern: `?{ T f, ... }`. In general, a filter is defined by:
+
+```bnf
+filter ::= name | '$' type_expr | '{' filter_label_list '}'
+   | '<' filter_label_list '>' | '(' filter_label_list ')'
+   | filter '=' name
+filter_label_list ::= /* empty */ | '...'
+   | ( filter label ',' ) * filter label
+```
+
+Examples:
+
+```k-repl
+  X                 -- any type
+  ( ... )           -- any type
+  { ... }           -- any product type
+  ( X x, X y )      -- any type with two fields of the same type
+  < X x, ... > = X  -- a (recursive) type, 'X', with variant 'x'
+                    -- of the same type 'X' 
+```
 
 ### Partial functions
 
@@ -52,14 +81,17 @@ A _partial function_ is a function that is not defined for every value of its do
 
 There are three ways of combining partial functions:
 
-1. __Composition__: we write a composition of `f` and `g` as `(f  g)`, meaning that if `f` is defined on value `x` producing `y`,
+1. __Composition__: we write a composition of `f` and `g` as `(f  g)`,
+   meaning that if `f` is defined on value `x` producing `y`,
    and `g` is defined on value `y` producing `z`, then `(f g)` is defined on value `x` producing `z`.
 2. __Union__: we write `< f1, f2 >` for a union of two functions `f1` and `f2`, meaning that
    if `f1` is defined on value `x` producing `y`, then `< f1, f2 >`
    is defined on value `x` producing `y`. Otherwise, i.e., when `f1` is not defined for `x`, `< f1 f2 >` acts as `f2`.
-3. __Product__: we write `{f1 lab1, f2 lab2 }` for a product of two functions `f1` and `f2`, meaning that if `f1` and `f2`
-   are both defined on value `x` producing `y1` and `y2`, respectively, then `{f1 lab1, f2 lab2 }`
-   is defined on value `x` producing `{y1 lab1, y2 lab2}`. Otherwise, `{f1 lab1, f2 lab2 }` is not defined for `x`.
+3. __Product__: we write `{f1 lab1, f2 lab2 }` for a product of two functions `f1` and `f2`,
+   meaning that if `f1` and `f2` are both defined on value `x` producing `y1` and `y2`,
+   respectively, then `{f1 lab1, f2 lab2 }` is defined on value `x` producing
+   `{y1 lab1, y2 lab2}`. 
+   Otherwise, `{f1 lab1, f2 lab2 }` is not defined for `x`.
 
 Actually, composition, union, and product combine any number of partial functions, not only two. For example,
 empty composition, `()`, defines the identity function.
@@ -72,41 +104,32 @@ which is the partial function the program defines.
 The language syntax is defined by:
 
 ```bnf
-program ::= (type_definition | function_definition) * expression
-
+program ::= (type_definition | function_definition)* expression
 type_definition ::= '$' type_name '=' type ';'
-type ::= '{' type_label_list '}' | '<' type_label_list '>'
-type_label_list ::= /* empty */ | ( type_expression label_name ',' ) + type_expression label_name
-type_expression ::= type_name | type
-
-function_definition ::= function_name '=' expression ';'
-expression ::= projection | typing | filter | composition | union | product | function_name
-projection ::= '.' label_name
-typing ::= '$' type_expression 
-filter ::= '?' filter_expression
-filter_expression ::= $ type_expression | filter_name 
-  | '{' filter_label_list '}' | '<' filter_label_list '>' | '(' filter_label_list ')'
-  | filter_expression '=' filter_name
-filter_label_list ::= /* empty */ | ( filter_expression label_name ',' ) * filter_expression label
+function_definition ::= name '=' expression ';'
+expression ::= name | '$' type | '?' filter 
+   | projection | composition | union | product 
+projection ::= '.' label
 composition ::= '(' expression * ')'  
 union ::= '<' (expression ',') + expression '>' 
-product ::= '{' expression_label_list '}'
-expression_label_list ::= /* empty */ | ( expression label_name ',' ) * expression label
+product ::= '{' expr_label_list '}'
+expr_label_list ::= /* empty */ 
+   | (expression label_name ',')* expression label
 ```
 
-We assume that in a `kernel-core` program the `type_name`, `function_name`, and `label_name` are identifiers (strings) such that:
+We assume that in a `kernel-core` program the names (for types, functions, and labels) are identifiers (strings) such that:
 
 1. All defined type names are distinct.
 2. All defined function names are distinct.
 3. All label names within a type definition or a `product` expression are locally distinct.
 
-The `typing` expression acts as a type annotation and can be seen as a 'filter', i.e., an identity
-function defined only for the values of the corresponding type.
+`Filter` or `type` expressions act as a type annotation, i.e., an identity
+function defined only for the values of the corresponding types.
 
 That's it.
 
 No `builtin` types, no `if` statement, no `loop`, no `throw`, no _closure_, no _annotations_, and no macros.
-Just types and partial functions.
+Just _types_, _filters_, and _functions_.
 
 ### Normalization
 
@@ -126,20 +149,21 @@ a dictionary  of _function definitions_, and the final _main expression_.
 In principle, the initial form of the Abstract Syntax Tree, _raw_ AST, is enough to evaluate
 the program on an input.
 
-Our objective however is to compute canonicals representations for types and normalized
+Our objective however is to compute canonical representations for types and normalized
 representations for functions, so they could be reused.
 
 The normalization steps are:
 
 1. Build the _type graph_ from all types used by the program, i.e., used in _type definitions_ 
    as well as type expressions used in _function definitions_ and the _main expression_.
-2. Annotate the expressions with types or type patterns; every node of the AST is annotated with a pair of type patterns.
-3. Turn the _singleton_ type patterns into types and add them to the _type graph_. Go to (2) unless no change.
+2. Annotate the expressions with filters; every node of the AST is annotated with a pair of filters.
+3. Turn the _singleton_ filters into types and add them to the _type graph_. Go to (2) unless no change.
 
+### Examples
 
-### Example
+#### Example 1
 
-```k
+```k-repl
 $ bit = < {} o, {} i >;
 bit0 = {{} o} $bit;
 bit1 = {{} i} $bit;
@@ -199,6 +223,33 @@ We can write it as: `?($byte byte, ((...) i, ...) overflown, ...)`.
 The target type `${ byte byte, bit overflown }` was derived from pattern `?{ $byte byte, $bit overflown }`.
 Such a pattern is called _singleton pattern_, as only one type fits the pattern.
 
+#### Example 2
+
+Polymorphic list functions:
+
+```k-repl
+list? = ?< {} nil, {X car, Y cdr} cons > = Y;
+nil = {{} nil} list?;
+singleton = {{() car, nil cdr} cons} list?;
+cons = {{.car car, .cdr cdr} cons} list?;
+nil? = list? .nil nil;
+car = list? .cons .car;
+cdr = list? .cons .cdr;
+```
+
+For example, the filter annotation for `car` is:
+
+```k-repl
+--R car
+{
+  name: 'yRXGSJrIWCuKV',
+  type: '?<{X1 car, X0 cdr} cons, $KL nil>=X0  -->  ?X1',
+  def: '?<{X1 car, X0 cdr} cons, $KL nil>=X0 .cons .car ?X1'
+}
+--C KL
+$ KL = {}; -- $C0={};
+```
+
 ## Universal Schema Registry
 
 Since the normalization process for types is fast and deterministic, we can build a universal

package/Code-derivation-tests/bnat.mjs

@@ -5,7 +5,7 @@ import assert from 'assert';
 t(fs.readFileSync("./Examples/bnat-patterns.k").toString("utf8"), (annotated) => {
     // console.log(JSON.stringify(annotated,null,2));
     const {input,output} = in_out(annotated);
-    // console.log(output);
+    console.log(output);
     assert.equal(output.type, annotated.representatives["bnat"]);
     assert.equal(input.type, annotated.representatives["pair"]);
     console.log("OK");

package/README.md

@@ -54,7 +54,7 @@ the property doesn't exist. E.g.,
 
 There are three ways of combining functions:
 
-1. **composition**: `(f1 f2 ...)`, e.g. `(.toto .titi)` extracts
+1. **Composition**: `(f1 f2 ...)`, e.g. `(.toto .titi)` extracts
     nested field.
 
     ```text
@@ -64,7 +64,7 @@ There are three ways of combining functions:
             {"other": {}}            ... undefined
     ```
 
-2. **merge**: `< f1, f2,... >`, e.g., `<.toto, .titi>` extracts field
+2. **Merge**: `< f1, f2,... >`, e.g., `<.toto, .titi>` extracts field
     `toto` if present; otherwise extracts `titi`.
 
     ```text
@@ -74,7 +74,7 @@ There are three ways of combining functions:
             {"x":{"o":{}}, "z": {"o":{}}}  ... undefined
     ```
 
-3. **product**: `{ f1 label1, f2 label2, ...}`, e.g., `{.toto TOTO,
+3. **Product**: `{ f1 label1, f2 label2, ...}`, e.g., `{.toto TOTO,
     .titi TITI}` extracts two fields and builds a record out of them.
 
     ```text
@@ -86,9 +86,9 @@ There are three ways of combining functions:
 
 **QUIZ**: What is:
 
-- empty composition: `()` ?
-- empty merge: `<>` ?
-- empty product: `{}` ?
+- Empty composition: `()` ?
+- Empty merge: `<>` ?
+- Empty product: `{}` ?
 - `{{{{} s} s} s}` ?
 - `({{{() a} b} c} .c .b .a)` ?
 
@@ -96,9 +96,9 @@ There are three ways of combining functions:
 
 ### Syntactic sugar
 
-- parenthesis can be omitted, except for the empty composition `()`,
-- dot (`.`) in "projection" acts as a separator so the space around it
-  can be omitted.
+- Parenthesis can be omitted, except for the empty composition `()`,
+- dot (`.`) in "projection" acts as a separator, so the surrounding
+  space can be omitted.
 
 For example, `(.toto .titi (.0 .1))` can be written as `.toto.titi.0.1`.
 
@@ -148,8 +148,8 @@ projection, via (`.`), to the canonical string representation of the value, e.g.
 
 #### Vector product
 
-Vector product can be seen as an abbreviation for product whose all fields
-have the same type, and the filed names are integers starting from zero.  
+The vector product can be seen as a shorthand for a product in which all fields
+have the same type, and the field names are integers starting from zero.
 E.g., `{.toto 0, .titi 1, 123 2}` can be written as  
 `[.toto, .titi, 123]`.
 
@@ -531,7 +531,7 @@ For example:
 
 ## k-REPL (Read-Evaluate-Print Loop)
 
-Also there is a REPL, `k-repl` (`./node_modules/.bin/k-repl`),
+Also, there is a REPL, `k-repl` (`./node_modules/.bin/k-repl`),
 which acts like a toy shell for the language.
 
 ```k-repl
@@ -552,72 +552,74 @@ Very! experimental repl shell for 'k-language'...
 
 ## Using `k` from `javascript`
 
-     import k from "@fraczak/k";
+```javascript
+import k from "@fraczak/k";
 
-     let k_expression = '()';
-     k.run(k_expression,"ANYTHING...");
-     // RETURNS: "ANYTHING..."
+let 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 = '{"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]
+k_expression = '[.year, .age]';
+k.run(k_expression,{"year":2002,"age":19});
+// RETURNS: [2002,19]
 
-     k_expression = '[(), ()]';
-     k.run(k_expression,"duplicate me");
-     // RETURNS: ["duplicate me","duplicate me"]
+k_expression = '[(), ()]';
+k.run(k_expression,"duplicate me");
+// RETURNS: ["duplicate me","duplicate me"]
 
-     k_expression = '[[[()]]]';
-     k.run(k_expression,"nesting");
-     // RETURNS: [[["nesting"]]]
+k_expression = '[[[()]]]';
+k.run(k_expression,"nesting");
+// RETURNS: [[["nesting"]]]
 
-     k_expression = '[[()]] {() nested, .0.0 val}';
-     k.run(k_expression,"nesting and accessing");
-     // RETURNS: {"nested":[["nesting and accessing"]],"val":"nesting and accessing"}
+k_expression = '[[()]] {() nested, .0.0 val}';
+k.run(k_expression,"nesting and accessing");
+// RETURNS: {"nested":[["nesting and accessing"]],"val":"nesting and accessing"}
 
-     k_expression = '0000';
-     k.run(k_expression,{"test":"parse integer"});
-     // RETURNS: 0
+k_expression = '0000';
+k.run(k_expression,{"test":"parse integer"});
+// RETURNS: 0
 
-     k_expression = '[.y,.x] PLUS';
-     k.run(k_expression,{"x":3,"y":4});
-     // RETURNS: 7
+k_expression = '[.y,.x] PLUS';
+k.run(k_expression,{"x":3,"y":4});
+// RETURNS: 7
 
-     var k_fn = k.compile('{.name nom, <[.age, 18] GT .0, [.age, 12] GT "ado", "enfant"> age}');
+var k_fn = k.compile('{.name nom, <[.age, 18] GT .0, [.age, 12] GT "ado", "enfant"> age}');
 
-     k_fn({"age":23,"name":"Emily"});
-     // RETURNS: {"nom":"Emily","age":23}
+k_fn({"age":23,"name":"Emily"});
+// RETURNS: {"nom":"Emily","age":23}
 
-     k_fn({"age":16,"name":"Katrina"});
-     // RETURNS: {"nom":"Katrina","age":"ado"}
+k_fn({"age":16,"name":"Katrina"});
+// RETURNS: {"nom":"Katrina","age":"ado"}
 
-     k_fn({"age":2,"name":"Mark"});
-     // RETURNS: {"nom":"Mark","age":"enfant"}
+k_fn({"age":2,"name":"Mark"});
+// RETURNS: {"nom":"Mark","age":"enfant"}
 
-     k_fn = k.compile('$t = < i: int, t: [ t ] > ; <$t, $int>');
+k_fn = k.compile('$t = < i: int, t: [ t ] > ; <$t, $int>');
 
-     k_fn(1);
-     // RETURNS: 1
+k_fn(1);
+// RETURNS: 1
 
-     k_fn({"i":1});
-     // RETURNS: {"i":1}
+k_fn({"i":1});
+// RETURNS: {"i":1}
 
-     k_fn([{"i":2},{"i":3},{"t":[]}]);
-     // RETURNS: undefined
+k_fn([{"i":2},{"i":3},{"t":[]}]);
+// RETURNS: undefined
 
-     k_fn({"t":[{"i":2},{"i":3},{"t":[]}]});
-     // RETURNS: {"t":[{"i":2},{"i":3},{"t":[]}]}
+k_fn({"t":[{"i":2},{"i":3},{"t":[]}]});
+// RETURNS: {"t":[{"i":2},{"i":3},{"t":[]}]}
 
-     k_fn = k.compile('$ < < [ int ] ints, [ bool ] bools > list, string None>');
+k_fn = k.compile('$ < < [ int ] ints, [ bool ] bools > list, string None>');
 
-     k_fn({"None":"None"});
-     // RETURNS: {"None":"None"}
+k_fn({"None":"None"});
+// RETURNS: {"None":"None"}
 
-     k_fn({"list":{"ints":[]}});
-     // RETURNS: {"list":{"ints":[]}}
+k_fn({"list":{"ints":[]}});
+// RETURNS: {"list":{"ints":[]}}
 
-     k_fn({"list":{"ints":[1,2,3]}});
-     // RETURNS: {"list":{"ints":[1,2,3]}}
+k_fn({"list":{"ints":[1,2,3]}});
+// RETURNS: {"list":{"ints":[1,2,3]}}
+```

package/export.mjs

@@ -2,7 +2,7 @@
 import { prettyRel, patterns2filters } from "./pretty.mjs";
 import { hash } from "./hash.mjs";
 
-function simplifyRel(relDef) {
+function simplifyRel(relDef,rels) {
   // remove filters and codes
   const prune = (rel) => {
     const newRel = {...rel};
@@ -32,6 +32,13 @@ function simplifyRel(relDef) {
       case 'code':
       case 'filter':
         newRel.op = "identity";
+        break;
+      case 'ref':
+        // console.log("ref", rel.ref, rels[rel.ref]);
+        if (["filter","code","identity"].includes(rels[rel.ref]?.def.op)){
+          newRel.op = "identity";
+        };
+        break;
       default:
         break;
     };
@@ -44,13 +51,13 @@ function simplifyRel(relDef) {
   const newRel = prune(rel);
   let resultRel = {...newRel};
   if (newRel.op == "identity")
-    return filters[0]; 
+    return {...resultRel, ...filters[0]}; 
 
   if (newRel.op == "comp") { 
     resultRel.comp = [ filters[0], ...newRel.comp, filters[1] ];
     return resultRel;
   }
-  return {
+  return {...resultRel,
     op: "comp",
     comp: [filters[0], newRel, filters[1] ]
   };
@@ -108,11 +115,12 @@ function assignCanonicalNames(scc, rels, relAlias) {
     const relDef = rels[relName];
     if (relDef.def.op == "ref" && rels[relDef.def.ref] != undefined) {
       // inlining if direct alias to a non built-in relation
-      relDef.simplified = simplifyRel(rels[relDef.def.ref]);
+      // relDef.def = rels[relDef.def.ref]; // simplifyRel(rels[relDef.def.ref],rels);
+      rels[relName] = rels[relDef.def.ref];
     } else {
-      relDef.simplified = simplifyRel(relDef);
+      relDef.def = simplifyRel(relDef,rels);
     }
-    newAlias[relName] = theID(relAlias, relDef.simplified, scc, relName);
+    newAlias[relName] = theID(relAlias, rels[relName].def, scc, relName);
     return newAlias;
   }, {});
   const newNames = [...new Set(Object.values(newAlias))];

package/package.json

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

package/parser.jison

@@ -43,7 +43,7 @@ function fromEscString(escString) {
 
 %%
 [/][*]([^*]*[*]+[^*/])*[^*]*[*]+[/]             /* c-comment */
-("//"|"#"|"%"|"--")[^\n]*                       /* one line comment */
+("//"|"#"|"%"|"--"|"\\")[^\n]*                  /* one line comment */
 \s+                                             /* blanks */
 "<"                                            return 'LA';
 "{"                                            return 'LC';

package/parser.mjs

@@ -846,7 +846,7 @@ case 25:return 47;
 break;
 }
 },
-rules: [/^(?:[/][*]([^*]*[*]+[^*/])*[^*]*[*]+[/])/,/^(?:(\/\/|#|%|--)[^\n]*)/,/^(?:\s+)/,/^(?:<)/,/^(?:\{)/,/^(?:\[)/,/^(?:\()/,/^(?:>)/,/^(?:\})/,/^(?:\])/,/^(?:\))/,/^(?:=)/,/^(?:\.\.\.)/,/^(?:\.)/,/^(?:,)/,/^(?:;)/,/^(?::)/,/^(?:\$)/,/^(?:\?)/,/^(?:\|)/,/^(?:\^)/,/^(?:"([^"\\]|\\(.|\n))*"|'([^'\\]|\\(.|\n))*')/,/^(?:[a-zA-Z_][a-zA-Z0-9_?!]*)/,/^(?:0|[-]?[1-9][0-9]*)/,/^(?:\+\+\+)/,/^(?:$)/],
+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,23,24,25],"inclusive":true}}
 });
 return lexer;

package/patterns.mjs

@@ -8,7 +8,7 @@ import { assignCanonicalNames } from "./export.mjs";
 const unitCode = codes.unitCode;
 
 function relDefToString(relDef) {
-
+  const start = new Date().getTime();
   const dumpPatterns = (rel) => {
     switch (rel.op) {
       case "product":
@@ -39,14 +39,20 @@ function relDefToString(relDef) {
   // console.log(relDef.typePatternGraph.edges);
   // console.log(relDef.def);
   
-  return JSON.stringify(dumpPatterns(relDef.def).map((x) => {
+  const result = JSON.stringify(dumpPatterns(relDef.def).map((x) => {
     const { pattern, fields, type} = relDef.typePatternGraph.get_pattern(x);
     return {pattern, fields, type};
   }));
+
+  let took = new Date().getTime() - start;
+  if (took > 200) {
+    console.log(` -- RelDefToString: size=${result.length}, took ${took} msecs`);
+  }
+  return result;
 }
 
 function compactRel(relDef, name = "") {
-  // console.log("********************************* compacting", name);
+  const start = new Date().getTime();
   const {def, typePatternGraph, varRefs } = relDef;
   // console.log("COMPACTING typePatternGraph of size", typePatternGraph.size());
 
@@ -92,14 +98,17 @@ function compactRel(relDef, name = "") {
     outputPatternId: renumbering[x.outputPatternId]
   }));;
     
-  // console.log(`COMPACTED ${name}.typePatternGraph`, typePatternGraph.size(), '->', newTypePatternGraph.size());
+  const time = new Date().getTime() - start;
+  if (time > 500 ) {
+    console.log(`[${new Date().getTime() - start} msecs] - COMPACTED ${name}.typePatternGraph [${typePatternGraph.size()}->${newTypePatternGraph.size()}]`);
+  }
   return {def: newDef, typePatternGraph: newTypePatternGraph, varRefs: newVarRefs};
 }
 
 function patterns(representatives, rels) {
   // INPUT: 
-  //   codes: {"BG": {"code": "product", "product": {}}, ...}
-  //   representatives:{"{}": "BG", ...}
+  //   codes: {"KL": {"code": "product", "product": {}}, ...}
+  //   representatives:{"{}": "KL", ...}
   //   rels: {"rlz": [{op: comp,...}, ...], ...}
  
   const relAlias = {};
@@ -407,7 +416,7 @@ function patterns(representatives, rels) {
         rel.patterns = [rootDef.typePatternGraph.addNewNode(), rootDef.typePatternGraph.addNewNode()];
         break;
       default:
-        throw new Error(`No definition found for ${rel.ref}`);  
+        throw new Error(`No definition found for '${rel.ref}'`);  
     }
   }  
 
@@ -462,7 +471,7 @@ function patterns(representatives, rels) {
   //    we will also generate the canonical representation of the relations in C and replace 
   //    the name to the relation by the hash of the canonical representation    
 
-  // console.log("----- SCC in order", sccInOrder);
+  // console.log("- SCC in order", sccInOrder);
 
   for (const scc of sccInOrder) {
 
@@ -470,7 +479,7 @@ function patterns(representatives, rels) {
     
     for (let iteration = 1; iteration <= maxNumberOfIterations; iteration++) {
       
-      // console.log(`>>>>>> Iteration ${iteration}  for SCC: { ${DAGnodes[scc].scc} }`);
+      // console.log(`-- Iteration ${iteration}/${maxNumberOfIterations} for SCC: { ${DAGnodes[scc].scc} }`);
       //    4.1 For every r in C, compute the new typePatternGraph of r, i.e.:
 
       let before = JSON.stringify(DAGnodes[scc].scc.map( relName => {
@@ -481,11 +490,11 @@ function patterns(representatives, rels) {
         // console.log(relDefToString(rels[relName]));
         return relDefToString(rels[relName]);
       }));
-    
+
       let after = JSON.stringify(DAGnodes[scc].scc.map( relName => {
         const relDef = compactRel(rels[relName],relName);
         for (let i = 0; i < relDef.varRefs.length; i++) {
-          // console.log(` ####### Processing ${relName}(..x${i}=${relDef.varRefs[i].varName}..)`);
+          const start = new Date().getTime();
           let varRel = relDef.varRefs[i];
           let { varName } = varRel;
           try {
@@ -493,7 +502,6 @@ function patterns(representatives, rels) {
             let varInputPatternId = varRootDef.typePatternGraph.find(varRootDef.def.patterns[0]);
             let varOutputPatternId = varRootDef.typePatternGraph.find(varRootDef.def.patterns[1]);
             let cloned = varRootDef.typePatternGraph.clone([varInputPatternId, varOutputPatternId], relDef.typePatternGraph);
-              
             relDef.typePatternGraph.unify(`ref:input ${relName}(${varName})`, varRel.inputPatternId, cloned[varInputPatternId]);
             relDef.typePatternGraph.unify("ref:output", varRel.outputPatternId, cloned[varOutputPatternId]);
           } catch (e) {
@@ -502,6 +510,10 @@ function patterns(representatives, rels) {
  - ${e.message}`;       
             throw e;
           }
+          const tookMs = new Date().getTime() - start;
+          if (tookMs > 200) {
+            console.log(` ---- Processing ${relName}(.., x${i}=${relDef.varRefs[i].varName}, ..) took: ${tookMs} ms`); 
+          }
         }
         rels[relName] = compactRel(relDef,relName);
         return relDefToString(rels[relName]); 

package/repl.mjs

@@ -51,8 +51,8 @@ rl.on('line', (line) => {
   process.exit(0);
 });
 
-let old_val = {};
-let val = {};
+let old_val = k.compile("{}")({});
+let val = old_val;
 const printVal = function (v = val) {
   if (v === undefined)
     console.log("...",v);
@@ -140,6 +140,9 @@ function evaluate(line) {
         codeName = codeName.slice(1);
       const canonicalName = run.defs.representatives[codeName] || codeName;
       const codeExp = find( canonicalName );
+      if (codeExp.def == "builtin") {
+        return console.log(` $ ${canonicalName} = :builtin;`);
+      }
       console.log(` $ ${canonicalName} = ${prettyCode(run.defs.representatives, codeExp)}; -- ${codeExp.def}`);
       // --pp
     } else if (line.match(/^[ \n\t]*(?:--pp)?$/)) {
@@ -187,7 +190,7 @@ function evaluate(line) {
       console.log({
         name: canonicalRelName,
         type: `${filtersStr[0]}  -->  ${filtersStr[1]}`,
-        def: prettyRel(rel.simplified)
+        def: prettyRel(rel.def)
       });
       if (DEBUG_FLAG) {
         val = exportRelation(run.defs.rels, run.defs.relAlias, relName);

package/typing.mjs

@@ -3,20 +3,36 @@ import codes from "./codes.mjs";
 
 const unitCode = codes.unitCode;
 
-function asMapSet(vector) { 
-  return vector.reduce( (mapSet, x) => ({...mapSet, [JSON.stringify(x)]: x}), {})
+function asSet(vector) { 
+  return Array.from(new Set(vector));
 };
 
 function setUnion(...vectors) {
-  return Object.values(asMapSet([].concat(...vectors)));
+  const unionSet = new Set();
+  for (const v of vectors) {
+    for (const element of v) {
+      unionSet.add(element);
+    }
+  }
+  return Array.from(unionSet);
 }
 
 function subsetP(v1,v2) {
-  const v2Set = asMapSet(v2);
-  return Object.keys(asMapSet(v1)).every(x => x in v2Set);
+  const v2Set = new Set(v2);
+  return v1.every(x => v2Set.has(x));
 }
+
 function eqsetP(v1,v2) {
-  return subsetP(v1,v2) && subsetP(v2,v1);
+  const v1Set = new Set(v1);
+  const v2Set = new Set(v2);
+  if (v1Set.size != v2Set.size) return false;
+
+  for (const value of v1Set) {
+    if (!v2Set.has(value)) {
+      return false;
+    }
+  }
+  return true;
 }
 
 const matchAllPattern = {pattern: '(...)', fields: []};
@@ -76,7 +92,7 @@ class TypePatternForest {
     // const node = {...flatTypePattern, _id: id};
     const node = {...flatTypePattern}
     that.nodes.push(node);
-    Object.values(asMapSet(children.map(that.find.bind(that))))
+    Array.from(new Set(children.map(that.find.bind(that))))
     .forEach(rep => {that.parent[rep] = id});
     return id;
   }
@@ -139,7 +155,6 @@ class TypePatternGraph {
     for( const id of singletonPatterns) {
       this.unify('singleton', id, this.getTypeId(representatives[`-${id}-`]));
     }
-
   }
 
 
@@ -165,27 +180,29 @@ class TypePatternGraph {
       )
     );
 
-    const gEdgesWithoutParrallelEdges  = Object.values(asMapSet(gEdges));
-   
+    const gEdgesWithoutParrallelEdges  = Array.from(new Set(gEdges));
     const gGraph = new Graph(gEdgesWithoutParrallelEdges);
     const queue = gNodes.filter(x => 
       this.patterns.nodes[x].pattern in {'()':1, '(...)':1,'{...}':1, '<...>':1});
-    const excluded = asMapSet(queue);
+    const excludedSet = new Set(queue);
+
     while (queue.length > 0) {
       const x = queue.pop();
       for (const e of gGraph.dst[x] || []) {
         const y = gGraph.edges[e].src;
-        if (y in excluded) continue;
-        excluded[y] = y;
+        if (excludedSet.has(y)) continue;
+        excludedSet.add(y);
         queue.push(y);
       }
     }
-    return gNodes.filter(x => !((x in excluded) || (this.patterns.nodes[x].pattern == 'type')));
+
+    return gNodes.filter(x => !((excludedSet.has(x)) || (this.patterns.nodes[x].pattern == 'type')));
   }
 
   getCompressed() {
     const newTypePatternGraph = new TypePatternGraph();
     const renamed = this.cloneAll(newTypePatternGraph);
+
     newTypePatternGraph.turnSingletonPatternsIntoCodes();
 
     Object.keys(renamed).forEach( id => {
@@ -223,7 +240,9 @@ class TypePatternGraph {
     
     // console.log("equivalence", equivalence);
 
+    let count = 0;
     const areDifferent = (i1,i2) => {
+      count++;
       const p1 = newTypePatternGraph.get_pattern(i1);
       const p2 = newTypePatternGraph.get_pattern(i2);
       if (p1.pattern != p2.pattern) return true;
@@ -239,7 +258,9 @@ class TypePatternGraph {
       return false;
     }
     let changed = true;
+    let count2 = 0;
     while (changed) {
+      count2++;
       changed = false;
       const equivalenceSize = equivalence.length;
       for (let eqClassPos = 0; eqClassPos < equivalenceSize; eqClassPos++) {
@@ -285,7 +306,7 @@ class TypePatternGraph {
     for (const oldId in newIds) {
       const newId = newIds[oldId];
       const pattern = newTypePatternGraph.get_pattern(oldId);
-      const newPattern = compressedTypePatternGraph.get_pattern(newId);
+      // const newPattern = compressedTypePatternGraph.get_pattern(newId);
       // console.log("patterns", pattern, newPattern);
       if (pattern.pattern == 'type') 
         continue;
@@ -294,7 +315,7 @@ class TypePatternGraph {
       compressedTypePatternGraph.edges[newId] = {};
       for (const lab in edges) {
         // console.log("edges[lab]", edges[lab]);
-        compressedTypePatternGraph.edges[newId][lab] = asMapSet(Object.values(edges[lab]).map(x => 
+        compressedTypePatternGraph.edges[newId][lab] = asSet(edges[lab].map(x => 
           newIds[reps[newTypePatternGraph.find(x)][0]]));
       }
     }
@@ -308,6 +329,7 @@ class TypePatternGraph {
     // console.log("nodes", compressedTypePatternGraph.patterns.nodes);
     // console.log("edges", compressedTypePatternGraph.edges);
     // console.log("--------------------")
+
     return {typePatternGraph: compressedTypePatternGraph, remapping};
   }
 
@@ -343,7 +365,7 @@ class TypePatternGraph {
       const new_id = result[i];
       targetGraph.edges[new_id] = {};
       for (const lab in edges) {
-        targetGraph.edges[new_id][lab] = asMapSet(Object.values(edges[lab]).map(x => result[find(x)]));
+        targetGraph.edges[new_id][lab] = asSet(edges[lab].map(x => result[find(x)]));
       }
     }
     return result;
@@ -584,7 +606,7 @@ class TypePatternGraph {
 
   unify(rule, ...ids) {
     const find = (x) => this.find(x);
-    const reps = Object.values(asMapSet(ids.map(find)));
+    const reps = Array.from(new Set(ids.map(find))); 
     if (reps.length < 2) return false;
     const rep_patters = reps.map(x => {
       const pattern = this.get_pattern(x);
@@ -615,8 +637,8 @@ class TypePatternGraph {
       for (const lab in edges) {
         // if the pattern is [] all labels are treated as 'vector-member'
         const new_lab = new_pattern.pattern == '[]' ? 'vector-member' : lab;
-        const dests = asMapSet(Object.values(edges[lab]).map(find));
-        this.edges[new_id][new_lab] = {...this.edges[new_id][new_lab], ...dests};
+        const dests = asSet(edges[lab].map(find));
+        this.edges[new_id][new_lab] = asSet([...(this.edges[new_id][new_lab] || []), ...dests]);
       }
     }
     // add stuff for types
@@ -629,7 +651,7 @@ class TypePatternGraph {
             // all edges are goin to unit type
             const unit_id = this.getTypeId(unitCode);
             for (const lab in this.edges[new_id]) {
-              this.edges[new_id][lab][unit_id] = unit_id;
+              this.edges[new_id][lab] = asSet([unit_id]);
             }
           }; break;
           case 'product':
@@ -637,7 +659,7 @@ class TypePatternGraph {
             const type_fields = Object.keys(code[code.code]);
             for (const lab of type_fields) {
               const target_type_id = this.getTypeId(code[code.code][lab]);
-              this.edges[new_id][lab]= {...this.edges[new_id][lab], [target_type_id]: target_type_id};
+              this.edges[new_id][lab]= asSet([...(this.edges[new_id][lab] ||[]), target_type_id]);
             }
           }; break;
           case 'vector': {
@@ -645,18 +667,13 @@ class TypePatternGraph {
             const target_type_id = this.getTypeId(code.vector);
 
             this.edges[new_id] = {
-              'vector-member': {
-                [target_type_id]: target_type_id, 
-                ...asMapSet( 
-                  setUnion(...Object.values(this.edges[new_id]).map(aSet => Object.values(aSet)))
-                )
-              }
+              'vector-member': asSet([ target_type_id, ...Object.values(this.edges[new_id])])
             }
           }
         }
     }
     for ( const lab of Object.keys(this.edges[new_id]) ) {
-      this.unify(rule+'.', ...Object.values(this.edges[new_id][lab]));      
+      this.unify(rule+'.', ...this.edges[new_id][lab]);      
     }
 
     return true;
@@ -667,7 +684,7 @@ class TypePatternGraph {
     const find = (x) => this.patterns.find(x);
     this.edges[id] = {};
     for (const [lab,dest] of Object.entries(fields)) {
-      this.edges[id][lab] = asMapSet(dest.map(find));
+      this.edges[id][lab] = asSet(dest.map(find));
     }
     return id;
   }