@fraczak/k 3.1.0 → 4.0.0

package/typing.mjs

@@ -183,6 +183,134 @@ class TypePatternGraph {
     return gNodes.filter(x => !((x in excluded) || (this.patterns.nodes[x].pattern == 'type')));
   }
 
+  getCompressed() {
+    const newTypePatternGraph = new TypePatternGraph();
+    const renamed = this.cloneAll(newTypePatternGraph);
+    newTypePatternGraph.turnSingletonPatternsIntoCodes();
+
+    Object.keys(renamed).forEach( id => {
+      renamed[id] = newTypePatternGraph.find(renamed[id]);
+    });
+
+    // console.log("newTypePatternGraph", newTypePatternGraph);
+    // console.log("nodes", newTypePatternGraph.patterns.nodes);
+    // console.log("edges", newTypePatternGraph.edges);
+
+    const rootPatternIds = newTypePatternGraph.patterns.nodes.map((x,i) => i)
+    .filter(x => newTypePatternGraph.find(x) == x);
+
+    // console.log("rootPatternIds", rootPatternIds);
+
+    const equivalence = rootPatternIds.reduce( (equivalence,i) => {
+      const pattern = newTypePatternGraph.get_pattern(i);
+      switch (pattern.pattern) {
+        case 'type':
+        case '(...)':
+        case '{...}':
+        case '<...>':
+          equivalence.push([i]);
+          break; 
+        default:
+          equivalence[0].push(i);
+      };
+      return equivalence;
+    }, [[]]).filter(x => x.length > 0);
+
+    const reps = equivalence.reduce( (reps,eqClass) => {
+      eqClass.forEach( x => reps[x] = eqClass);
+      return reps;
+    }, {});
+    
+    // console.log("equivalence", equivalence);
+
+    const areDifferent = (i1,i2) => {
+      const p1 = newTypePatternGraph.get_pattern(i1);
+      const p2 = newTypePatternGraph.get_pattern(i2);
+      if (p1.pattern != p2.pattern) return true;
+      const e1 = newTypePatternGraph.edges[i1];
+      const e2 = newTypePatternGraph.edges[i2];
+      if (Object.keys(e1).length != Object.keys(e2).length) return true;
+      for (const lab in e1) {
+        if (e2[lab] == undefined) return true;
+        const dests1 = Object.values(e1[lab])[0];
+        const dests2 = Object.values(e2[lab])[0];
+        if (reps[dests1] != reps[dests2]) return true;
+      }
+      return false;
+    }
+    let changed = true;
+    while (changed) {
+      changed = false;
+      const equivalenceSize = equivalence.length;
+      for (let eqClassPos = 0; eqClassPos < equivalenceSize; eqClassPos++) {
+        const eqClass = equivalence[eqClassPos];
+        const oldClass = [eqClass[0]];
+        const newClass = [];
+        for (let i = 1; i < eqClass.length; i++) {
+          if (areDifferent(oldClass[0],eqClass[i])) {
+            newClass.push(eqClass[i]);
+          } else {
+            oldClass.push(eqClass[i]);
+          }
+        }
+        if (newClass.length > 0) {
+          changed = true;
+          equivalence.push(newClass);
+          equivalence[eqClassPos] = oldClass;
+          for (const i of newClass) {
+            reps[i] = newClass;
+          }
+          for (const i of oldClass) {
+            reps[i] = oldClass;
+          }
+        }
+      }
+    }
+
+    // console.log("equivalence (final)", equivalence);
+    // console.log("reps", reps);
+
+    const compressedTypePatternGraph = new TypePatternGraph();
+    const newIds = {};
+    for (const eqClass of equivalence) {
+      // console.log("eqClass", eqClass);
+      const oldId = eqClass[0];
+      const pattern = newTypePatternGraph.get_pattern(oldId);
+      const newId = (() => {
+        if (pattern.pattern == 'type') return compressedTypePatternGraph.getTypeId(pattern.type);
+        return compressedTypePatternGraph.patterns.addNewNode(pattern);
+      })();
+      newIds[oldId] = newId;
+    }
+    for (const oldId in newIds) {
+      const newId = newIds[oldId];
+      const pattern = newTypePatternGraph.get_pattern(oldId);
+      const newPattern = compressedTypePatternGraph.get_pattern(newId);
+      // console.log("patterns", pattern, newPattern);
+      if (pattern.pattern == 'type') 
+        continue;
+      const edges = newTypePatternGraph.edges[oldId];
+      // console.log("edges", edges);
+      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 => 
+          newIds[reps[newTypePatternGraph.find(x)][0]]));
+      }
+    }
+
+    const remapping = Object.keys(renamed).reduce( (remapping,id) => {
+      return {...remapping, [id]: newIds[ reps[renamed[id]][0] ]};
+    }, {});
+    
+    // console.log("remapping", remapping);
+    // console.log("compressedTypePatternGraph", compressedTypePatternGraph);
+    // console.log("nodes", compressedTypePatternGraph.patterns.nodes);
+    // console.log("edges", compressedTypePatternGraph.edges);
+    // console.log("--------------------")
+    return {typePatternGraph: compressedTypePatternGraph, remapping};
+  }
+
   clone(roots,targetGraph = this) { 
     const result = {}; // mapping from original ids to cloned ids
     const find = (x) => this.find(x);
@@ -240,7 +368,8 @@ class TypePatternGraph {
             if (subsetP(p1.fields, p2.fields)) return p2;
             throw new Error(`Cannot unify (${p1.fields},...) with (${p2.fields})`);
           case '[]':
-            return p2;
+            if (p1.fields.every(x => `${x}`.match(/^[0-9]+$/))) return p2;
+            throw new Error(`Cannot unify [] with (${p1.fields},...)`);
           case '{}':
             if (subsetP(p1.fields, p2.fields)) return p2;
             throw new Error(`Cannot unify (${p1.fields},...) with {${p2.fields}}`);
@@ -283,7 +412,8 @@ class TypePatternGraph {
             if (subsetP(p1.fields, p2.fields))
               return {pattern: '{}', fields: p2.fields};
           case '[]':
-            return p2;
+            if (p1.fields.every(x => `${x}`.match(/^[0-9]+$/))) return p2;
+            throw new Error(`Cannot unify [] with {${p1.fields},...}`);
           case '{}':
             if (subsetP(p1.fields, p2.fields)) return p2;
             throw new Error(`Cannot unify {${p1.fields},...} with {${p2.fields}}`);
@@ -319,6 +449,17 @@ class TypePatternGraph {
           case 'type':{
             const code = codes.find(p2.type);
             switch (code.code) {
+              case 'int':
+                // supports (2 .2) which returns unit
+                if (p1.fields.every(x => `${x}`.match(/^[0-9]+$/))) 
+                  return p2;
+                break;
+              case 'string':
+                return p2;
+              case 'bool':
+                if (p1.fields.every(x => `${x}`.match(/^true|false$/)))
+                  return p2;
+                break;
               case 'union': {
                 let p2_fields = Object.keys(code[code.code]);
                 if (subsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
@@ -328,7 +469,7 @@ class TypePatternGraph {
           };
         }; 
         break;
-      case '()':
+      case '()': // Pattern '()' can be introduced by filter e.g., ?(X x, Y x)
         switch (p2.pattern) {
           case '()':
             if (eqsetP(p1.fields, p2.fields)) return p2;
@@ -337,18 +478,32 @@ class TypePatternGraph {
             if (eqsetP(p1.fields, p2.fields)) return p2;
             throw new Error(`Cannot unify (${p1.fields}) with {${p2.fields}}`);
           case '[]':
-            return p2;
+            if (p1.fields.every(x => `${x}`.match(/^[0-9]+$/))) return p2;
+            throw new Error(`Cannot unify [] with (${p1.fields})`);
           case '<>':
             if (eqsetP(p1.fields, p2.fields)) return p2;
             throw new Error(`Cannot unify (${p1.fields}) with <${p2.fields}>`);
           case 'type':{
             const code = codes.find(p2.type);
             switch (code.code) {
+              case 'int':
+                if (p1.fields.every(x => `${x}`.match(/^[0-9]+$/))) 
+                  return p2;
+                break;
+              case 'string':
+                return p2;
+              case 'bool':
+                if (p1.fields.every(x => `${x}`.match(/^true|false$/)))
+                  return p2;
+                break;
               case 'product':
               case 'union': {
                 let p2_fields = Object.keys(code[code.code]);
                 if (eqsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
-              }
+              }; break;
+              case 'vector':
+                if (p1.fields.every(x => `${x}`.match(/^[0-9]+$/))) 
+                  return {...p2, fields: ['vector-member']};
             }
             throw new Error(`Cannot unify ${JSON.stringify(p1)} with code ${p2.type}:${code.def}`);
           };
@@ -356,10 +511,11 @@ class TypePatternGraph {
         break;
       case '[]':
         switch (p2.pattern) {
-          case '[]':
-            if (eqsetP(p1.fields, p2.fields)) return p2;
-            throw new Error(`Cannot unify [${p1.fields}] with [${p2.fields}]`);
           case '{}':
+            // if (p2.fields.every(x => `${x}`.match(/^[0-9]+$/))) 
+            // return p1;
+            throw new Error(`Cannot unify [] with {${p2.fields}}`);
+          case '[]':
             return p1;
           case '<>':
             throw new Error('Cannot unify [] with <>');
@@ -435,8 +591,13 @@ class TypePatternGraph {
       const fields = Object.keys(this.edges[x] || {});
       return {...pattern, fields: fields};
     });
-    const new_pattern = {...this.unify_patterns(...rep_patters), rule : rule};
-    // console.log(`   new pattern: ${JSON.stringify(new_pattern)}`);
+
+    const new_pattern = (() => { try {
+      return {...this.unify_patterns(...rep_patters), rule : rule}
+    } catch (e) {
+      e.message = `Unification rule "${rule}"\n - ${e.message}`;
+      throw e;
+    } })();
     const new_id = (() => {
       if (new_pattern.pattern == 'type') {
         const id = this.getTypeId(new_pattern.type);
@@ -524,5 +685,5 @@ class TypePatternGraph {
   }
 }
 
-export {TypePatternForest, TypePatternGraph};
-export default {TypePatternForest, TypePatternGraph};
+export { TypePatternGraph };
+export default { TypePatternGraph };

package/INTRO.md

@@ -1,88 +0,0 @@
-### Introduction to Kernel/Core
-
-**Kernel/Core** is a minimal, gradually typed, first-order functional programming language designed for defining and transforming data using partial functions. It is built on the foundation of Algebraic Data Types (ADTs), specifically tagged unions and products.
-
-#### Core Concepts
-
-1. **Statements**:
-   - The program consists of a possibly empty list of statements, each ending with a semicolon (`;`), followed by an expression.
-   - There are two types of statements:
-     - **Code Definitions**: Define data types and start with a dollar sign (`$`).
-     - **Relation Definitions**: Define partial functions (transformations) of data.
-
-2. **Codes**:
-   - Codes represent data types and can be either unions (`<...>`) or products (`{...}`).
-   - Example: 
-     ```kernelcore
-     $ bool = <{} true, {} false>;
-     $ pair_of_bools = {bool x, bool y};
-     ```
-
-3. **Relations**:
-   - Relations are partial functions defined to transform data from one type to another.
-   - Example:
-     ```kernelcore
-     is_x_true = $pair_of_bools (.x .true);
-     ```
-
-4. **Composition of Partial Functions**:
-   - **Sequential (Functional) Composition**: Sequential application of partial functions.
-     ```kernelcore
-     (.x .true)
-     ```
-   - **Parallel (Product) Composition**: Combine multiple partial functions to construct a new product type.
-     ```kernelcore
-     {.x x_value, .y y_value}
-     ```
-   - **Concurrent (Union) Composition**: Try different functions in sequence, returning the first successful result.
-     ```kernelcore
-     <{.x .true false_bool}, {} true_bool>
-     ```
-
-5. **Constants**:
-   - Constants are defined as partial functions that ignore their input.
-   - Example:
-     ```kernelcore
-     true_bool = {{} true} $bool;
-     false_bool = {{} false} $bool;
-     ```
-
-#### Example Program
-
-```kernelcore
-// Define a boolean type as a union of true and false
-$ bool = <{} true, {} false>;
-
-// Define a pair of booleans as a product of two booleans
-$ pair_of_bools = {bool x, bool y};
-
-// Check if the `x` field is `true`
-is_x_true = $pair_of_bools (.x .true);
-
-// Extract both `x` and `y` fields into a new product
-extract_both = $pair_of_bools {.x x_value, .y y_value} $pair_of_bools;
-
-// Check if either `x` or `y` is `true`
-is_any_true = $pair_of_bools <{.x .true false_bool}, {} true_bool> $bool;
-
-// Define constants
-true_bool = {{} true} $bool;
-false_bool = {{} false} $bool;
-
-// Create instances of `pair_of_bools`
-pair1 = {true_bool x, true_bool y} $pair_of_bools;
-pair2 = {true_bool x, false_bool y} $pair_of_bools;
-pair3 = {false_bool x, false_bool y} $pair_of_bools;
-
-// Example usage of the functions
-result1 = pair1 is_x_true;       // Should return true
-result2 = pair2 is_x_true;       // Should return true
-
-both_values = pair1 extract_both; // Should return {x_value true, y_value true}
-
-any_true1 = pair1 is_any_true;   // Should return true
-any_true2 = pair2 is_any_true;   // Should return true
-any_true3 = pair3 is_any_true;   // Should return false
-```
-
-This brief introduction covers the fundamental concepts of Kernel/Core, enabling you to start defining data types and writing partial functions to transform data.