@fraczak/k 2.1.6 → 3.0.1

package/bug.json

@@ -0,0 +1,419 @@
+{
+  "rels": {
+    "xy": [
+      {
+        "op": "comp",
+        "comp": [
+          {
+            "op": "dot",
+            "dot": "x",
+            "start": {
+              "line": 1,
+              "column": 6
+            },
+            "end": {
+              "line": 1,
+              "column": 8
+            },
+            "patterns": [
+              2,
+              3
+            ]
+          },
+          {
+            "op": "ref",
+            "ref": "y",
+            "start": {
+              "line": 1,
+              "column": 9
+            },
+            "end": {
+              "line": 1,
+              "column": 10
+            },
+            "patterns": [
+              3,
+              4
+            ]
+          }
+        ],
+        "start": {
+          "line": 1,
+          "column": 6
+        },
+        "end": {
+          "line": 1,
+          "column": 10
+        },
+        "patterns": [
+          2,
+          4
+        ]
+      }
+    ],
+    "y": [
+      {
+        "op": "dot",
+        "dot": "y",
+        "start": {
+          "line": 2,
+          "column": 5
+        },
+        "end": {
+          "line": 2,
+          "column": 7
+        },
+        "patterns": [
+          0,
+          1
+        ]
+      }
+    ],
+    "__main__": [
+      {
+        "op": "comp",
+        "comp": [
+          {
+            "op": "code",
+            "code": "BrQwZuzvQqL",
+            "start": {
+              "line": 8,
+              "column": 1
+            },
+            "end": {
+              "line": 8,
+              "column": 7
+            },
+            "patterns": [
+              9,
+              9
+            ]
+          },
+          {
+            "op": "product",
+            "product": [
+              {
+                "label": "one",
+                "exp": {
+                  "op": "comp",
+                  "comp": [
+                    {
+                      "op": "dot",
+                      "dot": "one",
+                      "start": {
+                        "line": 8,
+                        "column": 9
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 13
+                      },
+                      "patterns": [
+                        9,
+                        5
+                      ]
+                    },
+                    {
+                      "op": "ref",
+                      "ref": "xy",
+                      "start": {
+                        "line": 8,
+                        "column": 14
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 16
+                      },
+                      "patterns": [
+                        5,
+                        6
+                      ]
+                    }
+                  ],
+                  "start": {
+                    "line": 8,
+                    "column": 9
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 16
+                  },
+                  "patterns": [
+                    9,
+                    6
+                  ]
+                }
+              },
+              {
+                "label": "two",
+                "exp": {
+                  "op": "comp",
+                  "comp": [
+                    {
+                      "op": "dot",
+                      "dot": "two",
+                      "start": {
+                        "line": 8,
+                        "column": 22
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 26
+                      },
+                      "patterns": [
+                        9,
+                        7
+                      ]
+                    },
+                    {
+                      "op": "ref",
+                      "ref": "xy",
+                      "start": {
+                        "line": 8,
+                        "column": 27
+                      },
+                      "end": {
+                        "line": 8,
+                        "column": 29
+                      },
+                      "patterns": [
+                        7,
+                        8
+                      ]
+                    }
+                  ],
+                  "start": {
+                    "line": 8,
+                    "column": 22
+                  },
+                  "end": {
+                    "line": 8,
+                    "column": 29
+                  },
+                  "patterns": [
+                    9,
+                    8
+                  ]
+                }
+              }
+            ],
+            "start": {
+              "line": 8,
+              "column": 8
+            },
+            "end": {
+              "line": 8,
+              "column": 34
+            },
+            "patterns": [
+              9,
+              10
+            ]
+          }
+        ],
+        "start": {
+          "line": 8,
+          "column": 1
+        },
+        "end": {
+          "line": 10,
+          "column": 3
+        },
+        "patterns": [
+          9,
+          10
+        ]
+      }
+    ]
+  },
+  "codes": {
+    "DBO": {
+      "code": "product",
+      "product": {},
+      "def": "$C0={};"
+    },
+    "BDAJxzVAZYX": {
+      "code": "union",
+      "union": {
+        "y": "DBO",
+        "a": "DBO"
+      },
+      "start": {
+        "line": 3,
+        "column": 7
+      },
+      "end": {
+        "line": 3,
+        "column": 21
+      },
+      "def": "$C0=<C1\"a\",C1\"y\">;$C1={};"
+    },
+    "CDRPHMxTHrX": {
+      "code": "union",
+      "union": {
+        "y": "DBO",
+        "b": "DBO"
+      },
+      "start": {
+        "line": 4,
+        "column": 7
+      },
+      "end": {
+        "line": 4,
+        "column": 21
+      },
+      "def": "$C0=<C1\"b\",C1\"y\">;$C1={};"
+    },
+    "CJFCNvVySrW": {
+      "code": "product",
+      "product": {
+        "x": "CDRPHMxTHrX",
+        "yb": "DBO"
+      },
+      "start": {
+        "line": 6,
+        "column": 8
+      },
+      "end": {
+        "line": 6,
+        "column": 21
+      },
+      "def": "$C0={C1\"x\",C2\"yb\"};$C1=<C2\"b\",C2\"y\">;$C2={};"
+    },
+    "BrQwZuzvQqL": {
+      "code": "product",
+      "product": {
+        "one": "CJFCNvVySrW",
+        "two": "CJFCNvVySrW"
+      },
+      "start": {
+        "line": 7,
+        "column": 10
+      },
+      "end": {
+        "line": 7,
+        "column": 28
+      },
+      "def": "$C0={C1\"one\",C2\"two\"};$C1={C3\"x\",C4\"ya\"};$C2={C5\"x\",C4\"yb\"};$C3=<C4\"a\",C4\"y\">;$C4={};$C5=<C4\"b\",C4\"y\">;"
+    }
+  },
+  "representatives": {
+    "BrQwZuzvQqL": "BrQwZuzvQqL",
+    "CJFCNvVySrW": "CJFCNvVySrW",
+    "CDRPHMxTHrX": "CDRPHMxTHrX",
+    "BDAJxzVAZYX": "BDAJxzVAZYX",
+    "DBO": "DBO",
+    "{}": "DBO",
+    ":1": "DBO",
+    ":2": "DBO",
+    "ya": "BDAJxzVAZYX",
+    ":4": "DBO",
+    ":5": "DBO",
+    "yb": "CDRPHMxTHrX",
+    ":7": "DBO",
+    "one": "CJFCNvVySrW",
+    ":9": "DBO",
+    "two": "CJFCNvVySrW",
+    "input": "BrQwZuzvQqL"
+  },
+  "patternNodes": [
+    {
+      "_id": 6,
+      "code": null,
+      "type": null,
+      "closed": false
+    },
+    {
+      "_id": 7,
+      "code": null,
+      "type": null,
+      "closed": false
+    },
+    {
+      "_id": 26,
+      "code": null,
+      "type": null,
+      "closed": false,
+      "_from": "(0,1)"
+    },
+    {
+      "_id": 27,
+      "code": null,
+      "type": null,
+      "closed": false,
+      "_from": "(2,3)"
+    },
+    {
+      "_id": 28,
+      "code": null,
+      "type": null,
+      "closed": false,
+      "_from": "(4,5)"
+    },
+    {
+      "_id": 32,
+      "code": "CJFCNvVySrW",
+      "type": "code",
+      "closed": true,
+      "_from": "(14,15)"
+    },
+    {
+      "_id": 33,
+      "code": null,
+      "type": null,
+      "closed": false,
+      "_from": "(16,17)"
+    },
+    {
+      "_id": 35,
+      "code": "CJFCNvVySrW",
+      "type": "code",
+      "closed": true,
+      "_from": "(20,21)"
+    },
+    {
+      "_id": 36,
+      "code": null,
+      "type": null,
+      "closed": false,
+      "_from": "(22,23)"
+    },
+    {
+      "_id": 39,
+      "code": "BrQwZuzvQqL",
+      "type": "code",
+      "closed": true,
+      "_from": "((8,(9,10)),((18,19),((12,13),11)))"
+    },
+    {
+      "_id": 40,
+      "code": null,
+      "type": "product",
+      "closed": true,
+      "_from": "(24,25)"
+    }
+  ],
+  "patternEdges": {
+    "0": {
+      "y": 1
+    },
+    "1": {},
+    "2": {
+      "x": 3
+    },
+    "3": {},
+    "4": {},
+    "5": {},
+    "6": {},
+    "7": {},
+    "8": {},
+    "9": {
+      "one": 5,
+      "two": 7
+    },
+    "10": {
+      "one": 6,
+      "two": 8
+    }
+  }
+}

package/chatGPT.md

@@ -0,0 +1,235 @@
+# Key Concepts and Constructs of Kernel/Core
+
+1. **Program Structure**:
+   - Consists of a possibly empty list of statements, each ending with a semicolon (`;`), followed by an expression.
+   - Statements can be:
+     - **Code Definitions**: Define data types and start with a dollar sign (`$`).
+     - **Relation Definitions**: Define partial functions for data transformations.
+
+2. **Code Definitions (Data Types)**:
+   - **Union Types**: Defined using angle brackets (`<...>`).
+
+     ```kernelcore
+     $ bool = <{} true, {} false>;
+     ```
+
+   - **Product Types**: Defined using curly braces (`{...}`).
+
+     ```kernelcore
+     $ pair_of_bools = {bool x, bool y};
+     ```
+
+3. **Relation Definitions (Partial Functions)**:
+   - **Projection (Field Extraction)**: Partial functions that extract fields from product types or check for specific variants in union types.
+
+     ```kernelcore
+     // Extract the `x` field from a pair_of_bools (product type)
+     extract_x = $pair_of_bools .x;
+     
+     // Extract the `y` field from a pair_of_bools (product type)
+     extract_y = $pair_of_bools .y;
+     
+     // Check if a bool is the `true` variant (union type)
+     check_true = $bool .true;
+     
+     // Check if a bool is the `false` variant (union type)
+     check_false = $bool .false;
+     ```
+
+   - **Sequential (Functional) Composition**: Sequential application of partial functions.
+
+     ```kernelcore
+     is_x_true = $pair_of_bools .x .true;
+     ```
+
+   - **Parallel (Product) Composition**: Combine multiple partial functions to construct a new product type.
+
+     ```kernelcore
+     extract_both = $pair_of_bools {.x x_value, .y y_value};
+     ```
+
+   - **Concurrent (Union) Composition**: Try different functions in sequence, returning the first successful result.
+
+     ```kernelcore
+     is_any_true = $pair_of_bools <.x .true true_bool, .y .true true_bool, false_bool>;
+     ```
+
+4. **Constants**:
+   - Constants are partial functions that ignore their input.
+
+     ```kernelcore
+     true_bool = {{} true};
+     false_bool = {{} false};
+     ```
+
+5. **Names and Labels**:
+   - Names and labels are alphanumerical sequences of ASCII characters, following the convention `[a-zA-Z_][a-zA-Z0-9_]*`.
+
+6. **Final Expression**:
+   - A final expression evaluates usage examples and collects results in a single product.
+
+     ```kernelcore
+     {pair1 is_x_true result1, 
+      pair2 is_x_true result2,
+      pair1 extract_both both_values, 
+      pair1 is_any_true any_true1, 
+      pair2 is_any_true any_true2, 
+      pair3 is_any_true any_true3}
+     ```
+
+## Complete 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};
+
+// Projection (Field Extraction)
+// Extract the `x` field from a pair_of_bools (product type)
+extract_x = $pair_of_bools .x;
+
+// Extract the `y` field from a pair_of_bools (product type)
+extract_y = $pair_of_bools .y;
+
+// Check if a bool is the `true` variant (union type)
+check_true = $bool .true;
+
+// Check if a bool is the `false` variant (union type)
+check_false = $bool .false;
+
+// 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};
+
+// Check if either `x` or `y` is `true`
+is_any_true = $pair_of_bools <.x .true true_bool, .y .true true_bool, false_bool>;
+
+// Define constants
+true_bool = {{} true};
+false_bool = {{} false};
+
+// Create instances of `pair_of_bools`
+pair1 = {true_bool x, true_bool y};
+pair2 = {true_bool x, false_bool y};
+pair3 = {false_bool x, false_bool y};
+
+// Final expression to evaluate usage examples
+{pair1 is_x_true result1, 
+ pair2 is_x_true result2,
+ pair1 extract_both both_values, 
+ pair1 is_any_true any_true1, 
+ pair2 is_any_true any_true2, 
+ pair3 is_any_true any_true3}
+```
+
+---
+
+## Kernel/Core Programming Language Overview
+
+**Goal**: To establish a minimal set of orthogonal constructs for describing data transformations as partial functions.
+
+### Basic Concepts
+
+1. **Data Types (Codes)**: Defined using tagged unions and product types.
+   - Union: `<>` denotes a union.
+   - Product: `{}` denotes a product.
+
+2. **Partial Functions (Relations)**: Defined for data transformations.
+    - Projection: Extract the value of a given field from product types or variant from union types, `.field_name`.
+    - Sequential Composition: sequence of partial function applications (`r1 r2 r3 ...`).
+    - Parallel Composition: `{r1 f1, r2 f2, ...}`.
+    - Concurrent Composition: `<r1, r2, ...>`.
+
+### Syntax
+
+- **Program Structure**: Consists of code and relation definitions, ending with a semicolon `;`, followed by an expression which defines the relation (i.e., the desired data transformation).
+
+- **Code Definition**: Introduces union or product types.
+
+  ```plaintext
+  $bool = <{} true, {} false>;
+  $pair_of_bools = {bool x, bool y};
+  ```
+
+- **Code annotations**:
+  Any code expression (prefixed by `$`) within a relation definition acts as a type annotation and can be seen as a partial identity function that copies its input to the output as long as the input value is of the type defined by the code expression.
+
+- **Constants**: 
+  Constants are partial functions (relations) that ignore their input. E.g., `{}` ignores the input and produces the empty product (unit). Any value (data point) will be represented by an expression defining the constant (i.e., the relation which ignores its input and returns the value). For representing a value of a union type we use the singleton parallel (product) composition with the only field corresponding to the variant. For example, `{{} true}` could represent the `true` variant of the `$bool`.  For a product type, we naturally use the parallel (product) composition, e.g., `{{{} true} x, {{} false} y}` could represent a data point of type `$pair_of_bools`.  
+
+  Singleton type definitions, by union or product, should be avoided as they do not bring any additional information and they cannot be distinguished from the variant or field they represent. E.g.:
+
+  ```plaintext
+  $unit_by_union = <{} unit>;  
+  $unit_by_product = {{} unit};
+  ```
+  
+  are equivalent to the empty product type `{}`.
+
+- **Relation Definition**: Defines helper relations.
+
+  ```plaintext
+  true_bool = {{} true} $bool;
+  false_bool = {{} false} $bool;
+  ```
+
+### Example Program
+
+```plaintext
+// Define data types
+$bool = <{} true, {} false>;
+$pair_of_bools = {bool x, bool y};
+
+// Define relations
+true_bool = {{} true} $bool;
+false_bool = {{} false} $bool;
+
+is_x_true = $pair_of_bools .x .true;
+is_y_true = $pair_of_bools .y .true;
+extract_both = $pair_of_bools {.x x_value, .y y_value};
+
+is_any_true = $pair_of_bools <.x .true true_bool, .y .true true_bool, false_bool>;
+
+// Create instances of pair_of_bools
+pair1 = {true_bool x, true_bool y};
+pair2 = {true_bool x, false_bool y};
+
+// Example usage of the functions
+{
+  (pair1 is_x_true)     pair1_x_true,
+  (pair1 is_y_true)     pair1_y_true,
+  (pair2 is_x_true)     pair2_x_true,
+  (pair2 is_y_true)     pair2_y_true,
+  (pair1 is_any_true)   pair1_any_true,
+  (pair2 is_any_true)   pair2_any_true,
+  (pair1 extract_both)  extracted1,
+  (pair2 extract_both)  extracted2
+}
+```
+
+## Key Concepts
+
+1. **Projections**: Partial functions for field extraction.
+
+   ```plaintext
+   .x, .y  // For product types
+   .true, .false  // For union types (act as checks)
+   ```
+
+2. **Constants**: Defined as partial functions that ignore their input.
+
+   ```plaintext
+   zero = {{} zero} $nat;
+   ```
+
+3. **Error Handling**: Kernel/core defines partial functions and does not have a notion of errors within the language. Execution errors (e.g., OOM, stack overflow) are handled by the operating system.
+
+4. **Global Names**: All names for relations and codes are global. Relation names and code names do not clash.
+
+5. **Gradual Typing**: Expressions cannot always be fully type-annotated, e.g., `.true` can be used where the input value has a union or product type with the variant/field 'true'.
+
+6. **Performance Considerations**: Partial functions can be optimized into "sequential transducers," "sequential functions," or a dynamic network of these. Full optimization is possible for the first two classes, with heuristics used for general cases.