@fraczak/k 5.1.1 → 6.0.0

package/core.k

@@ -0,0 +1,197 @@
+-- core.k — the k standard core library
+--
+-- Defines:
+--   1. $bits — the canonical binary number / bit-path type
+--   2. $string — unicode strings (used for labels)
+--   3. $pattern — the type of pattern graphs
+--   4. Basic $bits arithmetic: succ, plus, times
+
+---------------------------------------------------------------
+-- §1. Bits
+---------------------------------------------------------------
+
+$ bit = < {} 0, {} 1 >;
+b0 = {}|0 $bit;
+b1 = {}|1 $bit;
+
+$ bits = < {} _, bits 0, bits 1 >;
+
+_ = {}|_;
+
+0 = _ |0;
+1 = _ |1;
+
+inv = {() x, _ r} _inv;
+_inv = ${bits x, bits r} < {.x /0 x, .r |0 r} _inv, {.x /1 x, .r |1 r} _inv, .r >;
+
+concat = ${bits x, bits y} {.x inv x, .y y} concat_;
+concat_ = ${bits x, bits y}
+  <
+    {.x /0 x, .y |0 y} concat_,
+    {.x /1 x, .y |1 y} concat_,
+    .y
+  >;
+
+---------------------------------------------------------------
+-- §2. Bits arithmetic
+---------------------------------------------------------------
+
+-- successor (increment by 1)
+succ = {inv x, _ y} _inc;
+
+_inc = ${bits x, bits y} <
+    {.x /0 x, .y |1 y} concat_,
+    {.x /1 x, .y |0 y} _inc,
+    .y |1
+>;
+
+-- constants
+2 = 1 succ;
+3 = 2 succ;
+4 = 3 succ;
+5 = 4 succ;
+6 = 5 succ;
+7 = 6 succ;
+8 = 7 succ;
+9 = 8 succ;
+10 = 9 succ;
+
+-- addition on $bits (unsigned, LSB-first with carry)
+plus = ${bits x, bits y} {.x inv x, .y inv y, b0 c} _plus;
+_plus = ${bits x, bits y, bit c}
+  <
+    {.x /_ if, .y /_ and, <.c/0 0, 1> then} .then,
+    {.x /_ if, .c/0 and, .y then} .then,
+    {.x y, .y /_|_ x, .c c} _plus,
+    {<.c/0 0, 1> x, .y y, .x /_ b0 c} _plus,
+    {.x /0 x, .y /0 y, .c/0 b0 c} _plus |0,
+    {.x /0 x, .y /0 y, .c/1 b0 c} _plus |1,
+    {.x /0 x, .y /1 y, .c/0 b0 c} _plus |1,
+    {.x /0 x, .y /1 y, .c/1 b1 c} _plus |0,
+    {.x /1 x, .y /0 y, .c/0 b0 c} _plus |1,
+    {.x /1 x, .y /0 y, .c/1 b1 c} _plus |0,
+    {.x /1 x, .y /1 y, .c/0 b1 c} _plus |0,
+    {.x /1 x, .y /1 y, .c/1 b1 c} _plus |1
+  >;
+
+-- multiplication on $bits (unsigned, shift-and-add)
+times = ${bits x, bits y} {0 result, .x inv _x, .y y} _times;
+_times = ${bits result, bits _x, bits y}
+  <
+    { .y /_ if, .result then } .then,
+    {
+      .result |0 result,
+      ._x _x,
+      .y /0 y
+    } _times,
+    {
+      {._x x, .result |0 y, b0 c} _plus result,
+      ._x _x,
+      .y /1 y
+    } _times
+  >;
+
+---------------------------------------------------------------
+-- §3. Unicode and String
+---------------------------------------------------------------
+
+-- 8-bit octet used as a building block for UTF-8 payload pieces.
+$ byte = {
+  bit 0, bit 1, bit 2, bit 3,
+  bit 4, bit 5, bit 6, bit 7
+};
+
+-- 7-bit ASCII code point payload (U+0000..U+007F).
+$ ascii = { bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 };
+
+-- 11-bit payload used for Plane 0 code points U+0080..U+07FF.
+-- Plane 0 is the Basic Multilingual Plane (BMP): U+0000..U+FFFF.
+$ u0080_07FF = { bit 10, bit 9, bit 8, bit 7, bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 };
+
+-- High-byte classes for common BMP ranges, excluding surrogate/private-use partitions.
+-- BMP (Basic Multilingual Plane) is Plane 0: the first 65,536 code points.
+$ bmp_hi_common = <
+  { bit 2, bit 1, bit 0 } h08_0F,
+  { bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 } h10_7F,
+  { bit 6, bit 5, bit 4, bit 3, bit 2, bit 1, bit 0 } h80_CF,
+  { bit 2, bit 1, bit 0 } hD0_D7,
+  {} hF9,
+  { bit 0 } hFA_FB,
+  { bit 0 } hFC_FD,
+  { bit 0 } hFE_FF
+>;
+
+-- High-byte classes for BMP private-use/high-reserved slices.
+-- These partitions keep Plane 0 subsets explicit in the type encoding.
+$ bmp_hi_private_use = <
+  { bit 3, bit 2, bit 1, bit 0 } hE0_EF,
+  { bit 2, bit 1, bit 0 } hF0_F7,
+  {} hF8
+>;
+
+-- Plane selector for supplementary code points in Planes 2..16.
+-- Supplementary planes are all planes above BMP (Plane 0).
+$ plane_02_10 = <
+  { bit 0 } p02_03,
+  { bit 1, bit 0 } p04_07,
+  { bit 2, bit 1, bit 0 } p08_0F,
+  {} p10
+>;
+
+-- Canonical Unicode scalar-value partition used by string encoding.
+-- Branch meaning:
+-- - ascii: U+0000..U+007F (subset of BMP / Plane 0)
+-- - plane0: U+0080..U+07FF (still Plane 0)
+-- - bmp_common, bmp_private_use: U+0800..U+FFFF partitions (Plane 0)
+-- - supplementary_plane1: U+10000..U+1FFFF (Plane 1)
+-- - supplementary_planes2_16: U+20000..U+10FFFF (Planes 2..16)
+$ unicode = <
+  ascii ascii,
+  u0080_07FF plane0,
+  { bmp_hi_common hi, byte lo } bmp_common,
+  { bmp_hi_private_use hi, byte lo } bmp_private_use,
+  { byte mid, byte lo } supplementary_plane1,
+  { plane_02_10 plane, byte mid, byte lo } supplementary_planes2_16
+>;
+
+-- Linked-list string: nil or (unicode car, string cdr).
+$ string = < {} nil, { unicode car, string cdr } cons >;
+
+---------------------------------------------------------------
+-- §4. Pattern
+---------------------------------------------------------------
+
+-- Edge: a labeled edge in a pattern graph.
+-- 'label' is the field name or tag name.
+-- 'target' is the index (as $bits) of the target node in the pattern list.
+
+$ edge = { string label, bits target };
+
+-- Edge list: the edges of a pattern node, sorted by label.
+
+$ edges = < {} nil, { edge car, edges cdr } cons >;
+
+-- Pattern node: one of five kinds.
+-- "any" is the unconstrained position (...), carrying no edges.
+-- The four others carry their edge list directly.
+
+$ pattern-node = <
+  {} any,
+  edges open-product,
+  edges open-union,
+  edges closed-product,
+  edges closed-union
+>;
+
+-- Pattern: a cons-list of pattern nodes.
+-- Node 0 (first element) is the root.
+-- Edges reference nodes by their index in this list, encoded as $bits.
+--
+-- The singleton pattern of $pattern itself is a fixed constant.
+-- That constant is the implicit framing for all k wire formats:
+-- to decode any value, first decode a $pattern under that constant,
+-- then decode the value under the pattern just obtained.
+
+$ pattern = < {} nil, { pattern-node car, pattern cdr } cons >;
+
+$pattern

package/export.mjs

@@ -1,8 +1,17 @@
-
+import hash from "./hash.mjs";
 import { prettyRel, patterns2filters } from "./pretty.mjs";
-import { hash } from "./hash.mjs";
 
-function simplifyRel(relDef,rels) {
+function logNormalized(label, value, hashValue) {
+  if (process.env.K_DUMP_NORMALIZED) {
+    if (hashValue) {
+      console.log(`[k-normalize] ${label}: ${hashValue} = ${value}`);
+    } else {
+      console.log(`[k-normalize] ${label}: ${value}`);
+    }
+  }
+}
+
+export function simplifyRel(relDef,rels) {
   // remove filters and codes
   const prune = (rel) => {
     const newRel = {...rel};
@@ -23,12 +32,6 @@ function simplifyRel(relDef,rels) {
         if (newRel.comp.length == 0) 
           newRel.op = "identity";
         break;
-      case "vector":
-        newRel.vector = rel.vector.map(exp => prune(exp));
-        break;
-      case "caret":
-        newRel.caret = prune(rel.caret);
-        break;
       case 'code':
       case 'filter':
         newRel.op = "identity";
@@ -46,8 +49,8 @@ function simplifyRel(relDef,rels) {
   };
 
   const rel = relDef.def;
-  const filters = patterns2filters(relDef.typePatternGraph, ...rel.patterns).map( filter =>
-    ({op: "filter", filter: filter}));
+  const filters = patterns2filters(relDef.typePatternGraph, ...rel.patterns).map((filter, index) =>
+    ({op: "filter", filter: filter, patterns: [rel.patterns[index], rel.patterns[index]]}));
   const newRel = prune(rel);
   let resultRel = {...newRel};
   if (newRel.op == "identity")
@@ -57,13 +60,15 @@ function simplifyRel(relDef,rels) {
     resultRel.comp = [ filters[0], ...newRel.comp, filters[1] ];
     return resultRel;
   }
+
+  let oldOp = resultRel.op;
+  delete resultRel[oldOp];
   return {...resultRel,
     op: "comp",
     comp: [filters[0], newRel, filters[1] ]
   };
 };
 
-
 function theID(alias, rel, scc, name) {
   const sccNames = new Set(scc);
   const auxNames = {[name]: "X0"};
@@ -80,12 +85,6 @@ function theID(alias, rel, scc, name) {
       case "comp":
         newRel.comp = rel.comp.map(exp => reNameX(exp));
         break;
-      case "vector":
-        newRel.vector = rel.vector.map(exp => reNameX(exp));
-        break;
-      case "caret":
-        newRel.caret = reNameX(rel.caret);
-        break;
       case "ref": {
         const n = rel.ref;
         if (alias[n] != undefined) {
@@ -105,21 +104,21 @@ function theID(alias, rel, scc, name) {
 
   const newRel = reNameX(rel);
   const resultRelStr = prettyRel(newRel);
-  // console.log(` ${name} = ${resultRelStr}`);
   const newName = hash(resultRelStr);
+  logNormalized(name, resultRelStr, newName);
+  // console.log(` ${name} = ${resultRelStr}`);
   return newName;
 };
 
-function assignCanonicalNames(scc, rels, relAlias) {
+export function assignCanonicalNames(scc, rels, relAlias) {
   const newAlias = scc.reduce( (newAlias,relName) => {
     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.def = rels[relDef.def.ref]; // simplifyRel(rels[relDef.def.ref],rels);
       rels[relName] = rels[relDef.def.ref];
-    } else {
-      relDef.def = simplifyRel(relDef,rels);
     }
+    rels[relName].def = simplifyRel(rels[relName], rels);
     newAlias[relName] = theID(relAlias, rels[relName].def, scc, relName);
     return newAlias;
   }, {});
@@ -136,7 +135,7 @@ function assignCanonicalNames(scc, rels, relAlias) {
   };  
 }
 
-function exportRelation(rels, alias, name) {
+export function exportRelation(rels, alias, name) {
   const queue = [name];
   const inQueue = { [name]: true };
   const result = {};
@@ -152,12 +151,6 @@ function exportRelation(rels, alias, name) {
       case "comp":
         newRel.comp = rel.comp.map(exp => reName(exp));
         break;
-      case "vector":
-        newRel.vector = rel.vector.map(exp => reName(exp));
-        break;
-      case "caret":
-        newRel.caret = reName(rel.caret);
-        break;
       case "ref": {
         const n = rel.ref;
         if (alias[n] == undefined) // built-in
@@ -180,6 +173,3 @@ function exportRelation(rels, alias, name) {
   }
   return result;
 }
-
-export default { assignCanonicalNames, exportRelation };
-export { assignCanonicalNames, exportRelation };

package/hash.mjs

@@ -1,39 +1,37 @@
-const baseToShifted = {
-    '0': 'A', '1': 'B', '2': 'C', '3': 'D',
-    '4': 'E', '5': 'F', '6': 'G', '7': 'H',
-    '8': 'I', '9': 'J', 'a': 'K', 'b': 'L',
-    'c': 'M', 'd': 'N', 'e': 'O', 'f': 'P',
-    'g': 'Q', 'h': 'R', 'i': 'S', 'j': 'T',
-    'k': 'U', 'l': 'V', 'm': 'W', 'n': 'X',
-    'o': 'Y', 'p': 'Z', 'q': 'q', 'r': 'r',
-    's': 's', 't': 't', 'u': 'u', 'v': 'v',
-    'w': 'w', 'x': 'x', 'y': 'y', 'z': 'z'
-};
+import { createHash } from "node:crypto";
 
-const base = Object.keys(baseToShifted).length;
+const BASE56_ALPHABET = "23456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnpqrstuvwxyz";
+const BASE56_BASE = BigInt(BASE56_ALPHABET.length);
+const SHA256_BASE56_LENGTH = 45;
+function encodeBase56(bytes) {
+  let value = 0n;
+  for (const byte of bytes) {
+    value = (value << 8n) + BigInt(byte);
+  }
 
-function shifString(baseString) {
-    let shiftedString = '';
-    for (let i = 0; i < baseString.length; i++) {
-        shiftedString += baseToShifted[baseString[i]];
-    }
-    return shiftedString;
-}
+  let encoded = "";
+  while (value > 0n) {
+    const mod = value % BASE56_BASE;
+    encoded = BASE56_ALPHABET[Number(mod)] + encoded;
+    value /= BASE56_BASE;
+  }
 
-function hash(inputString) {
-    if (inputString.match(/^\$C0=.*;$/))
-        inputString = inputString.slice(4, -1);
-    
-    let hashValue = BigInt(0);
-    const prime = BigInt(2);
-    const mod = BigInt('8494462356974657160929849007317');
+  return encoded || BASE56_ALPHABET[0];
+}
 
-    for (let i = 0; i < inputString.length; i++) {
-        let charCode = BigInt(inputString.charCodeAt(i));
-        hashValue = (hashValue * prime + charCode) % mod;
-    }
+function hash(inputString, options = {}) {
+  const { short = false, minLength = 7 } = options;
+  let input = inputString;
+  if (input.match(/^\$C0=.*;$/)) {
+    input = input.slice(4, -1);
+  }
 
-    return "@"+shifString(hashValue.toString(base));
+  const digest = createHash("sha256").update(input).digest();
+  const full = encodeBase56(digest);
+  const padded = full.padStart(SHA256_BASE56_LENGTH, BASE56_ALPHABET[0]);
+  const trimmed = padded.slice(1);
+  const body = short ? trimmed.slice(0, Math.max(1, minLength)) : trimmed;
+  return "@" + body;
 }
 
 export default hash;

package/index.mjs

@@ -1,33 +1,59 @@
 import { parse } from "./parser.mjs";
-import { patterns } from "./patterns.mjs";
+import { Value, fromObject } from "./Value.mjs";
+import { parseValue } from "./valueIO.mjs";
+import { compileTypes } from "./compiler.mjs";
 import run from "./run.mjs";
-import t from "./codes.mjs";
-
-function compile(script) {
-  run.defs = annotate(script);
-  return run.bind(null, run.defs.rels.__main__.def);
+import codes from "./codes.mjs";
+
+function compile(script, options = {}) {
+  run.defs = annotate(script, options);
+  const mainRel = run.defs.rels.__main__;
+  return (value) => {
+    const result = run(codes.find, mainRel.def, value, mainRel.typePatternGraph);
+    if (result === undefined) return;
+    return result;
+  };
 }
 
 compile.doc = "Transforms k-script (string) into a function";
 
-function runScriptOnData(script, data) {
-  return compile(script)(data);
+function runScriptOnData(script, data, options = {}) {
+  let parsedData;
+  if (data instanceof Value) {
+    parsedData = data;
+  } else if (typeof data === "string") {
+    parsedData = parseValue(data, null, null);
+  } else  {
+    parsedData = fromObject(data);
+  }
+  return compile(script, options)(parsedData);
 }
 runScriptOnData.doc = "Run 'script' (string) on 'data': (script,data) -> data";
 
 
-function annotate(script) {
+function annotate(script, options = {}) {
   const { defs, exp } = parse(script);
-  //const { codes, representatives } = t.finalize(defs.codes);
 
-  const representatives = t.register(defs.codes);
+  const representatives = codes.register(defs.codes);
   const rels = {...defs.rels, "__main__": {def: exp}};
 
-  const relAlias = patterns(representatives, rels);
+  // Inject library relations into the rels table so @hash refs resolve
+  if (options.libraries) {
+    for (const lib of options.libraries) {
+      const libRels = lib.rels || lib.defs?.rels || {};
+      for (const [name, rel] of Object.entries(libRels)) {
+        if (!(name in rels)) {
+          rels[name] = { ...rel, _library: true };
+        }
+      }
+    }
+  }
+
+  const { relAlias, compileStats } = compileTypes(representatives, rels, options);
  
-  return {rels, representatives, relAlias};
+  return {rels, representatives, relAlias, compileStats};
 }
 annotate.doc = "Annotate all the script expressions with patterns";
 
-export default { compile, run: runScriptOnData, parse, annotate };
-export { compile, runScriptOnData as run, parse, annotate };
+export default { compile, run: runScriptOnData, parse, annotate, parseValue, fromObject };
+export { compile, runScriptOnData as run, parse, annotate, parseValue, fromObject };

package/k-vscode/.vscode/launch.json

@@ -0,0 +1,14 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Run K Language Extension",
+      "type": "extensionHost",
+      "request": "launch",
+      "runtimeExecutable": "${execPath}",
+      "args": [
+        "--extensionDevelopmentPath=${workspaceFolder}"
+      ]
+    }
+  ]
+}

package/k-vscode/README.md

@@ -0,0 +1,65 @@
+# k language — VS Code extension
+
+Syntax highlighting and snippets for the **k language**: a language for composing
+first-order partial functions over algebraic data types (products and tagged unions).
+
+## Features
+
+- **Syntax highlighting** for all current k constructs:
+  - Line comments (`--`, `//`, `%`, `#`) and block comments (`/* … */`)
+  - Named code (type) definitions: `$ name = …`
+  - Function/relation definitions: `name = …`
+  - All three operators: `.field` (product projection), `/tag` (union projection), `|tag` (variant introduction)
+  - Filter expressions: `?< … > = X`, `?{ … } = X` with pattern variables
+  - Type annotations: `$name`, `${…}`
+  - Canonical content-addressed references: `@base58hash`
+  - Quoted label strings: `"label"`, `'label'` (with escape sequences)
+  - The `...` any/open pattern marker
+- **Snippets** for every common pattern (trigger via `Tab` after prefix):
+
+| Prefix | Inserts |
+|--------|---------|
+| `codeunion` | Named code as tagged union |
+| `codeprod` | Named code as product |
+| `coderecunion` | Recursive named code |
+| `fn` | Function definition |
+| `comp` | Composition `(f g)` |
+| `merge` | Merge `< f, g >` |
+| `prod` | Product combinator `{ f l, g l }` |
+| `filtunion` | Filter union `?< … > = X` |
+| `filtprod` | Filter product `?{ … } = X` |
+| `dot` | `.field` |
+| `slash` | `/tag` |
+| `vid` | `\|tag` |
+| `typeref` | `$name` annotation |
+| `typedprod` | `${ type label, … }` typed input |
+| `id` | `()` identity |
+| `unit` | `{}` empty product (leaf) |
+| `undef` | `<>` always-undefined |
+
+- **Bracket matching and auto-close** for `{ }`, `( )`, `< >`, `"…"`, `'…'`
+- **Toggle line comment** bound to `--` (Ctrl+/ / Cmd+/)
+- **Word selection** understands k identifiers including `?`, `!`, `+`, `-`
+
+## Install
+
+### Run locally (development)
+
+1. Open the `k-vscode/` folder in VS Code.
+2. Press **F5** — this opens an Extension Development Host with the extension loaded.
+
+### Build and install a VSIX
+
+```bash
+cd k-vscode
+npm install
+npx vsce package        # produces k-language-0.2.0.vsix
+```
+
+Then in VS Code: **Extensions → ⋯ → Install from VSIX…** and select the generated file.
+
+## Notes
+
+- Language id: `k`
+- File extension: `.k`
+- The extension has no runtime dependencies.

package/k-vscode/language-configuration.json

@@ -0,0 +1,42 @@
+{
+  "comments": {
+    "lineComment": "--",
+    "blockComment": ["/*", "*/"]
+  },
+  "brackets": [
+    ["{", "}"],
+    ["(", ")"],
+    ["<", ">"]
+  ],
+  "autoClosingPairs": [
+    { "open": "{", "close": "}" },
+    { "open": "(", "close": ")" },
+    { "open": "<", "close": ">" },
+    { "open": "\"", "close": "\"" },
+    { "open": "'", "close": "'" },
+    { "open": "/*", "close": "*/" }
+  ],
+  "surroundingPairs": [
+    ["{", "}"],
+    ["(", ")"],
+    ["<", ">"],
+    ["\"", "\""],
+    ["'", "'"]
+  ],
+  "wordPattern": "[a-zA-Z0-9_+\\-][a-zA-Z0-9_?!+\\-]*",
+  "indentationRules": {
+    "increaseIndentPattern": "[{(<]\\s*$",
+    "decreaseIndentPattern": "^\\s*[})>]"
+  },
+  "onEnterRules": [
+    {
+      "beforeText": "/\\*.*\\*/$",
+      "action": { "indent": "none" }
+    },
+    {
+      "beforeText": "/\\*",
+      "afterText": "\\*/",
+      "action": { "indent": "indentOutdent" }
+    }
+  ]
+}

package/k-vscode/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "k-language",
+  "displayName": "k language",
+  "description": "Syntax highlighting and snippets for the k language — first-order partial functions over algebraic data types",
+  "publisher": "wojtek",
+  "version": "0.2.0",
+  "license": "ISC",
+  "homepage": "https://github.com/fraczak/k",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/fraczak/k.git"
+  },
+  "keywords": [
+    "k",
+    "algebraic",
+    "partial functions",
+    "ADT",
+    "types"
+  ],
+  "engines": {
+    "vscode": "^1.90.0"
+  },
+  "categories": [
+    "Programming Languages"
+  ],
+  "contributes": {
+    "languages": [
+      {
+        "id": "k",
+        "aliases": [
+          "k language",
+          "k"
+        ],
+        "extensions": [
+          ".k"
+        ],
+        "configuration": "./language-configuration.json"
+      }
+    ],
+    "grammars": [
+      {
+        "language": "k",
+        "scopeName": "source.k",
+        "path": "./syntaxes/k.tmLanguage.json"
+      }
+    ],
+    "snippets": [
+      {
+        "language": "k",
+        "path": "./snippets/k.json"
+      }
+    ]
+  },
+  "devDependencies": {
+    "@vscode/vsce": "^3.7.1"
+  }
+}