@fraczak/k 5.0.0 → 5.0.1

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/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.1",
     "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

@@ -98,8 +98,8 @@ function compactRel(relDef, name = "") {
 
 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 +407,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}'`);  
     }
   }  
 

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