@fraczak/k 3.0.2 → 3.1.0

package/BIG_PICTURE.md

@@ -170,7 +170,7 @@ Functions `bit0`, `bit1`, and `zero` are "constant polymorphic functions", meani
 
 - constant: if defined, they always return exactly the same value;
 - polymorphic: they are defined for more than one pair of input and output type: functions
-  `bit1` and `bit2` are of type `X -> bit`, and `zero` is of type `X -> byte`, where `X`
+  `bit0` and `bit1` are of type `X -> bit`, and `zero` is of type `X -> byte`, where `X`
   denotes an unconstrained type pattern.
 
 Functions `inc` and `inc3` are (non-polymorphic) functions of types
@@ -191,20 +191,29 @@ following constraints:
 The type pattern for `Y` is _singleton_, as only one type fits the pattern,
 whereas the other type patterns are not.
 
-In this example, we were able to find the most general type pattern for all sub-expressions of the program. However, we still do not have a way to find the most general type patterns in the general case. This is work in progress.
+In this example, we were able to find the most general type pattern for all sub-expressions of the program. 
+However, we still do not have a way to find the most general type patterns in the general case.
+This is work in progress.
 
 ## Universal Schema Registry
 
-Since the normalization process for types is fast and deterministic, we can build a universal schema registry that will store all invented types. The registry will be a key-value store, where the key is the hash of the normalized type, and the value is the normalized type itself.
+Since the normalization process for types is fast and deterministic, we can build a universal schema registry that will store all invented types. 
+The registry will be a key-value store, where the key is the hash of the normalized type, and the value is the normalized type itself.
 
 All functions (non-polymorphic and polymorphic) will be renamed by the hash of their normalized definition and stored in the similar key-value store.
 
-Non-polymorphic functions can be easily indexed by the hashes of their input and output types so that we can quickly find the function we need, e.g., for autocomplition. Searching for polymorphic functions is more complicated, as we need to find the function whose input and output type patterns fit given types.
-
+Non-polymorphic functions can be easily indexed by the hashes of their input and output types so that we can quickly find the function we need, e.g., for autocomplition.
+Searching for polymorphic functions is more complicated, as we need to find the function whose input and output type patterns fit given types.
 
 ## Serialization and Compilation
 
-The language is designed to transform _codes_, i.e., serialized typed values, i.e., trees accepted by a tree automaton, into other _codes_. The transformation is done by partial functions as defined in the language. The non-recursive and tail-recursive (and even some non-tail recursive) functions can be compiled into deterministic finite (pushdown) transducers.
+The language is designed to transform _codes_, i.e., serialized typed values, i.e., trees accepted by a tree automaton, into other _codes_.
+The transformation is done by partial functions as defined in the language.
+The non-recursive and tail-recursive (and even some non-tail recursive) functions can be compiled into deterministic finite (pushdown) transducers.
+
+### AND-OR graphs for enconding and decoding codes
+
+
 
 ## Linking with Other Languages
 

package/Code-derivation-tests/blowup.mjs

@@ -0,0 +1,27 @@
+import { t, in_out } from './index.mjs';
+import fs from 'node:fs';
+import assert from 'assert';
+
+// t(fs.readFileSync("./Examples/blowup.k").toString("utf8"), (annotated) => {
+//     // console.log(JSON.stringify(annotated,null,2));
+//     const {input,output} = in_out(annotated);
+//     console.log(input);
+//     console.log(output);
+//     assert.equal(output.pattern, '<...>');
+//     assert.equal(input.pattern, '(...)');
+//     console.log("OK");
+// });
+
+t(`
+  B = {{} u} A;
+  A = < .a, .b A, .c {() z} A, B  >;
+  A
+`, (annotated) => {
+    // console.log(JSON.stringify(annotated,null,2));
+    const {input,output} = in_out(annotated);
+    console.log(input);
+    console.log(output);
+    assert.equal(output.type, annotated.representatives["bnat"]);
+    assert.equal(input.type, annotated.representatives["pair"]);
+    console.log("OK");
+});

package/Code-derivation-tests/bnat.mjs

@@ -3,8 +3,10 @@ import fs from 'node:fs';
 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);
-    assert.equal(output.code, annotated.representatives["bnat"]);
-    assert.equal(input.code, annotated.representatives["pair"]);
+    // console.log(output);
+    assert.equal(output.type, annotated.representatives["bnat"]);
+    assert.equal(input.type, annotated.representatives["pair"]);
     console.log("OK");
 });

package/Code-derivation-tests/built-in.mjs

@@ -4,7 +4,7 @@ import assert from 'assert';
 function is_result_code(code) {
     return function(annotated) {
         const {output} = in_out(annotated);
-        assert.strictEqual(output.code, code);
+        assert.strictEqual(output.type, code);
         console.log('OK');
     }
 }

package/Code-derivation-tests/dot.mjs

@@ -9,7 +9,32 @@ $b {1 one, () two, () c} .one
 
 `, (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(input.code, annotated.representatives["b"]);
-    assert.equal(output.code, "int");
+    // console.log({input,output});
+    assert.equal(input.type, annotated.representatives["b"]);
+    assert.equal(output.type, "int");
     console.log("OK");
-});
+});
+
+t(`
+    $a = < int true, bool false > ;
+    $a .true
+  `, (annotated) => {
+  const {input,output} = in_out(annotated);
+  console.log({input,output});
+});
+
+t(`
+  x = .x;
+  xy = x.y;
+  f = { 
+    { {5    y} x} xy i, 
+    { {true y} x} xy b 
+  };
+  f .b
+`, (annotated) => {
+  const {input,output} = in_out(annotated);
+  console.log({input,output});
+  assert.equal(input.pattern, '(...)');
+    assert.equal(output.type, "bool");
+    console.log("OK");
+});

package/Code-derivation-tests/index.mjs

@@ -1,8 +1,8 @@
 import { annotate } from "../index.mjs";
 
 function in_out(annotated) {
-  const [input,output] = annotated.rels.__main__[0].patterns.map( (pat) => 
-    annotated.patternNodes[pat]
+  const [input,output] = annotated.rels.__main__.def.patterns.map( (pat) => 
+    annotated.rels.__main__.typePatternGraph.get_pattern(pat)
   );
   return { input, output };
 }

package/Code-derivation-tests/loop.mjs

@@ -3,7 +3,7 @@ import assert from 'assert';
 
 t(` < .a, () > `, (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(input.type, "union");
+    assert.equal(input.pattern, "(...)");
     assert.equal(output, input); 
     console.log("OK");
 }); 

package/Code-derivation-tests/nat.mjs

@@ -4,7 +4,7 @@ import assert from 'assert';
 
 t(fs.readFileSync("./Examples/nat.k").toString("utf8"), (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(output.code, annotated.representatives["nat"]);
-    assert.equal(input.code, annotated.representatives["nat"]);
+    assert.equal(output.type, annotated.representatives["nat"]);
+    assert.equal(input.type, annotated.representatives["nat"]);
     console.log("OK");
 });

package/Code-derivation-tests/not-not.mjs

@@ -8,7 +8,7 @@ t(`$b = < {} true, {} false > ;
    not not
 `, (annotated) => {
    const {input,output} = in_out(annotated);
-   assert.equal(input.code, annotated.representatives["b"]);
-   assert.equal(output.code, annotated.representatives["b"]);
+   assert.equal(input.type, annotated.representatives["b"]);
+   assert.equal(output.type, annotated.representatives["b"]);
    console.log("OK");
    });

package/Code-derivation-tests/product.mjs

@@ -1,10 +1,13 @@
 import { t, in_out } from './index.mjs';
 import assert from 'assert';
+import hash from "../hash.mjs";
+
+const unitCode = hash('$C0={};');
 
 t('{}', (annotated) => {
   const {input,output} = in_out(annotated);
-  assert.equal(input.type, null);
-  assert.equal(output.code, annotated.representatives["{}"]);
+  assert.equal(input.pattern, '(...)');
+  assert.equal(output.type, unitCode);
   console.log("OK");
 });
 
@@ -12,10 +15,11 @@ t(`
   $b = < {} true, {} false > ; 
   $pair = { b one, b two } ;
 
-   {() one, () two} $pair
+  {() one, () two} $pair
 `, (annotated) => {
   const {input,output} = in_out(annotated);
-  assert.equal(input.code, annotated.representatives["b"]);
-  assert.equal(output.code, annotated.representatives["pair"]);
+
+  assert.equal(input.type, annotated.representatives["b"]);
+  assert.equal(output.type, annotated.representatives["pair"]);
   console.log("OK");
 });

package/Code-derivation-tests/rlz.mjs

@@ -8,7 +8,7 @@ t(`
  rlz
  `, (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(output.code, annotated.representatives["nat"]);
-    assert.equal(input.code, annotated.representatives["nat"]);
+    assert.equal(output.type, annotated.representatives["nat"]);
+    assert.equal(input.type, annotated.representatives["nat"]);
     console.log("OK");
  });

package/Code-derivation-tests/vector.mjs

@@ -3,26 +3,20 @@ import assert from 'assert';
 
 t('[]', (annotated) => {
   const {input,output} = in_out(annotated);
-  assert.equal(input.type, null);
-  assert.equal(output.type, "vector");
+  assert.equal(input.pattern, '(...)');
+  assert.equal(output.pattern, "[]");
   console.log("OK");
 });
 
-t(`$int [ $int true, false ]`, (annotated) => {
+t("$int [ $int true, false ] .0",  (annotated) => {
   const {input,output} = in_out(annotated);
-  assert.equal(input.code, "int");
-  assert.equal(output.type, "vector");
+  assert.equal(input.type, "int");
+  assert.equal(output.type, "bool");
   console.log("OK");
 });
 
-t(`$int [ $int true, false ] .0`,  (annotated) => {
-  const {input,output} = in_out(annotated);
-  assert.equal(input.code, "int");
-  assert.equal(output.code, "bool");
-  console.log("OK");
-});
-
-// assert.throws(() => t(`$int [ $int true, 12 ]`), /Error/);
-// console.log("OK");
+assert.throws(() => t(`$int [ $int true, 12 ]`), /Error/);
+console.log("The both errors are expected...");
+console.log("OK");
 
 // t(`[]`);

package/Graph.mjs

@@ -0,0 +1,95 @@
+class Graph {
+  constructor(edges, vertices = {}) {
+    this.edges = edges;
+    this.vertices = vertices;
+    for (const dir of ['src', 'dst']) {
+      this[dir] = {};
+      for (let i=0; i < edges.length; i++) {
+        const e = edges[i];
+        if (vertices[e[dir]] == undefined) {
+          vertices[e[dir]] = {
+            _rem: "discovered"
+          };
+        }
+        if (this[dir][e[dir]] == null) {
+          this[dir][e[dir]] = [];
+        }
+        this[dir][e[dir]].push(i);
+      }
+    }   
+  }
+}
+
+function sccs(graph) {
+  const stack = [];
+  const disc = {};
+  const low = {};
+  const inStack = {};
+  const sccs = [];
+  let time = 0;
+
+  const dfs = (u) => {
+    disc[u] = low[u] = time++;
+    stack.push(u);
+    inStack[u] = true;
+
+    for (const e of graph.src[u] || []) {
+      const v = graph.edges[e].dst;
+      if (disc[v] == undefined) {
+        dfs(v);
+        low[u] = Math.min(low[u], low[v]);
+      } else if (inStack[v]) {
+        low[u] = Math.min(low[u], disc[v]);
+      }
+    }
+
+    if (low[u] === disc[u]) {
+      const scc = [];
+      let w;
+      do {
+        w = stack.pop();
+        inStack[w] = false;
+        scc.push(w);
+      } while (w !== u);
+      sccs.push(scc);
+    }
+  };
+
+  for (const x in graph.vertices) {
+    if (disc[x] == undefined) {
+      dfs(x);
+    }
+  }
+  return sccs;
+};
+
+function topoOrder(graph){
+  const starts = [];
+  const result = [];
+  const inDegree = {};
+  for (const v in graph.vertices) {
+    const degree = graph.dst[v]?.length || 0;
+    if (degree == 0) {
+      starts.push(v);
+    } else {
+      inDegree[v] = degree;
+    }
+  } 
+
+  let x;
+  while (x = starts.pop()) {
+    result.push(x);
+    const outs = graph.src[x] || [];
+    for (const e of outs) {
+      const y = graph.edges[e].dst;
+      inDegree[y]--;
+      if (inDegree[y] == 0) {
+        starts.push(y);
+      }
+    }
+  }
+  return result;
+}
+
+export { Graph, sccs, topoOrder };
+export default { Graph, sccs, topoOrder };