@fraczak/k 3.0.2 → 4.0.0

package/BIG_PICTURE.md

@@ -1,3 +1,4 @@
+# Big Picture
 
 `Kernel-code` is an experiment aiming to define a "perfect programming language".
 
@@ -22,7 +23,7 @@ Types are defined by two constructs:
 1. Product
 2. Union (also called tagged or disjoint union)
 
-Given a set (possibly empty) of types `t1, t2, ..., tn` and a set of pairwise different tags (labels) `l1, l2, ..., ln`,
+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` projection functions `.l1`, `.l2`, `...`, `.ln`,
   mapping a value of type `{t1 l1, t2 l2, ..., tn ln}` into a value of type `t1`, `t2`, `...`, `tn`, respectively.
@@ -42,7 +43,6 @@ Some properties of these types:
    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.
-4. The product and union types form dual categories.
 
 ### Partial functions
 
@@ -64,7 +64,7 @@ empty composition, `()`, defines the identity function.
 
 ### Program
 
-A `kernel-core` program is a set of definitions of types and partial functions followed by an _expression_,
+A `kernel-core` program is a set of definitions of types and partial functions, followed by an _expression_,
 which is the partial function the program defines.
 
 The language syntax is defined by:
@@ -97,7 +97,7 @@ The `typing` expression acts as a type annotation and can be seen as a 'filter',
 function defined only for the values of the corresponding type.
 
 That's it.
-No `int`, no `if` statement, no `loop`, no `throw`, no _closure_, no _annotations_, and no macros.
+No `builtin` types, no `if` statement, no `loop`, no `throw`, no _closure_, no _annotations_, and no macros.
 Just types and partial functions.
 
 ### Normalization
@@ -170,41 +170,59 @@ 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`
-  denotes an unconstrained type pattern.
+  `bit0` and `bit1` are of type `?X -> $bit`, and `zero` is of type `?X -> $byte`, where `?X`
+  denotes an unconstrained type pattern, also denoted as `?(...)`.
 
 Functions `inc` and `inc3` are (non-polymorphic) functions of types
-`byte -> { bit overflown, byte byte }` and
-`{ bit overflown, byte byte } -> { bit overflown, byte byte }`, respectively.
+`$byte -> ${ bit overflown, byte byte }` and
+`${ bit overflown, byte byte } -> ${ bit overflown, byte byte }`, respectively.
 
-Function `inc_o` is a polymorphic function of type patterns: `X -> Y` with
-following constraints:
+Function `inc_o` is a polymorphic function of type patterns: `?X -> ${ byte byte, bit overflown }` 
+with following constraints:
 
-- `X` is a product type with at least two fields: `byte` and `overflown`, denoted by:
-   > `?{ byte byte, Z overflown, ...}`;
-- `Z` is a type (union or product) with field `i` denoted by:
+- `?X` is a product or union type with at least two fields: `byte` and `overflown`, denoted by:
+   > `?( $byte byte, Z overflown, ...)`;
+- `?Z` is a type (union or product) with field `i` denoted by:
    > `?( V i, ...)`;
-- `V` is unconstrained;
-- `Y` is a product type with exactly two fields: `byte` and `overflown`, denoted by:
-   > `?{ byte byte, bit overflown }`;
+- `V` is unconstrained, denoted by `(...)`;
 
-The type pattern for `Y` is _singleton_, as only one type fits the pattern,
-whereas the other type patterns are not.
+We could write it as: `?($byte byte, ((...) i, ...) overflown, ...)`.
 
-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.
+The target type `${ byte byte, bit overflown }` was derived from pattern `?{ $byte byte, $bit overflown }`.
+Such a pettern is called _singleton pattern_ as only one type fits the pattern.
 
 ## 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.
+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.
+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
+
+This could be generic and compact way to encode and decode typed values.
+The idea is to use _prefix codes_ (a class of languages such that no word is a prefix of
+another word) to encode the values.
+
+### RUST data structures
+
+A type can be translated into a Rust data structure, and a function can be translated into a Rust function.
 
 ## 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,17 @@ 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");
-
-// t(`[]`);
+assert.throws(() => t(`$int [ $int true, 12 ]`), /Error/);
+console.log("OK");

package/Filters/bug.k

@@ -0,0 +1,3 @@
+swap = ?{<...> x, Y y} {.x y, .y x} .y ?Y; 
+
+{"asd" x, "a" y} swap .asd

package/Filters/composing.k

@@ -0,0 +1,15 @@
+remap = ?T {.x y} ?T ?<X z, ...>; 
+swap =  ?T {.x y, .y x} ?T;
+
+$t = <int x, int y>;
+
+$t2 = <int x, int y, int z>;
+
+-- {12 x} $t remap $t
+-- {[1,2] x} remap
+-- {"ala" x, 3 y} swap 
+
+{
+    {12 x} $t2 remap $t2 remap,
+    {"ala" x, "ola" y} swap 
+}

package/Filters/filter.k

@@ -0,0 +1,9 @@
+f1 = ?{T x, [T] y};
+f2 = ?{[R] x, R y};
+
+swap = f1 f2 {.x y, .y x};
+
+
+{[] x, [[[[]]]] y} swap
+
+-- shoud_work

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 };

package/README.md

@@ -87,7 +87,7 @@ supported.
 
 ### Basic extensions
 
-#### Constants, i.e., literals for `strings`, `integers`, `booleans`, and `null`
+#### Constants, i.e., literals for `string`, `int`, `bool`, and `null`
 
 A constant defines a function which ignores its argument and produces
 the constant value. E.g.:
@@ -95,7 +95,7 @@ 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
+Those values, i.e., _strings_, _integers_, _booleans_, and _null_, admit the
 projection to the canonicat string representation of the value, e.g.:
 
     .2 :
@@ -176,7 +176,6 @@ is not supported in _code derivation_ (explained below).
         "2.12"             --> 2.12
         "[1,2.11,0.3e-32]" --> [1,2.11,3e-33]
 
-
 - other predefined parial functions are: `DIV`, `FDIV`, `CONS`,
   `SNOC`, `toDateMsec`, `toDateStr`, and `_log!`.
 
@@ -185,10 +184,11 @@ is not supported in _code derivation_ (explained below).
 ### Function and code (i.e., _type_) definitions
 
       dec = [(),-1] PLUS;
-      max = <SNOC [.0, .1 max] <GT.0, .1>, .0> ;
+      max = <SNOC [.car, .cdr max] <GT.0, .1>, .0> ;
       factorial = < [(),0] GT .0 [dec factorial, ()] TIMES, 1 >;
 
-### Codes (schemas, i.e., _non-functional types_)
+### Codes (schemas, i.e., _types_)
+
 _Codes_ (prefixed by `$`) can be defined by tagged union and product. E.g.:
 
 
@@ -256,12 +256,15 @@ fail, indicating that the script is invalid.  In some other cases the
 code derivation can succeed even to the point of reducig every pattern
 to a single code making the program fully annotated by codes.
 
-For now, `code derivation` is supported by the core language, i.e., `composition`,
-`projection` and `union` with product and tagged union types.
+The language `k` supports _type patterns_, which is used for type inference, however the patterns are not concidered in the evaluation of the program.
+
+```k
+    tree_pattern = ?<(...) leaf, {T left, T right} tree> = T;
+```
 
 ---
 
-### List comprehension on vectors (experimental!)
+### List comprehension
 
 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", 
@@ -355,11 +358,11 @@ times value `x` appears in the list. (see `Examples/list-comprehension.k` for a
 Another example could be finding the biggest (max) value in a vector:
 
     max = < 
-      SNOC         #   [x0, x1, x2, ...] --> [x0, [x1, x2, ...]]
-      [.0, .1 max] #   [x0, [x1, x2, ...]] --> [x0, max(x1,x2,...)], i.e., recursive call 
-      <GT .0, .1>  #   if x0 > max(x1,x2,...) then x0 else max(x1,x2,...)
-    ,              # when SNOC is not defined, i.e., if the input vector has one element:
-      .0           #   [x0] --> x0
+      SNOC             #   [x0, x1, x2, ...] --> {x0 car, [x1, x2, ...] cdr}
+      [.car, .cdr max] #   [x0, [x1, x2, ...]] --> [x0, max(x1,x2,...)], i.e., recursive call 
+      <GT .0, .1>      #   if x0 > max(x1,x2,...) then x0 else max(x1,x2,...)
+    ,                  # when SNOC is not defined, i.e., if the input vector has one element:
+      .0               #   [x0] --> x0
     >; 
     max
 
@@ -468,10 +471,10 @@ For example:
 
 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 
+        curl 'https://api.github.com/repositories/5101141/commits?per_page=5' | k '()' -1 
 2.
         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 
+        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