@fraczak/k 5.0.1 → 5.0.2

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/package.json

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

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,7 +98,10 @@ 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};
 }
 
@@ -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/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;
   }