@fraczak/k 6.1.3 → 6.2.1

package/Examples/list.k

@@ -0,0 +1,7 @@
+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;

package/Examples/nat.k

@@ -0,0 +1,12 @@
+$ nat = < {} 0, nat +1 >;
+0 = {} | 0 ;
+0? = $ nat { / 0 if, () then} .then;
+succ = | +1 $ nat ;
+pred = $nat / +1 ;
+add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ?X add, .y> ;
+mult = <
+    {{.x pred x, .y y} mult x, .y y} add,
+    0
+> ;
+
+succ {()x,()y} add

package/Examples/vhdl_to_k.k

@@ -0,0 +1,50 @@
+-- VHDL to K Translation Patterns
+
+-- VHDL: signal a : std_logic;
+-- K:    $ bit = <{} 0, {} 1>;
+
+-- VHDL: signal bus : std_logic_vector(7 downto 0);
+-- K:    $ byte = {bit 0, bit 1, bit 2, bit 3, bit 4, bit 5, bit 6, bit 7};
+
+-- VHDL: entity adder is port(a,b: in std_logic; sum: out std_logic); end;
+-- K:    adder = ${bit a, bit b} {.a a_out, .b b_out, xor_gate sum_out};
+
+-- VHDL: process(clk) begin if rising_edge(clk) then q <= d; end if; end;
+-- K:    dff = $bit .;  -- Identity (register holds value)
+
+-- VHDL: y <= a and b;
+-- K:    and_gate = ${bit a, bit b} <{.a.1 1, .b.1 1, 1}, 0>;
+
+-- VHDL: y <= a or b;  
+-- K:    or_gate = ${bit a, bit b} <{.a.0 0, .b.0 0, 0}, 1>;
+
+-- VHDL: y <= not a;
+-- K:    not_gate = $bit <{.0 0, 1}, {.1 1, 0}>;
+
+-- VHDL: with sel select y <= a when "00", b when "01", c when others;
+-- K:    mux = ${bit sel0, bit sel1, bit a, bit b, bit c} <
+--             {.sel0.0 0, .sel1.0 0, .a},
+--             {.sel0.1 1, .sel1.0 0, .b}, 
+--             .c>;
+
+-- VHDL: architecture of 4-bit adder
+four_bit_adder = ${
+  {bit 0, bit 1, bit 2, bit 3} a,
+  {bit 0, bit 1, bit 2, bit 3} b
+} {
+  {.a.0 a0, .b.0 b0} full_adder fa0,
+  {.a.1 a1, .b.1 b1, .fa0.carry c_in} full_adder fa1,
+  {.a.2 a2, .b.2 b2, .fa1.carry c_in} full_adder fa2,
+  {.a.3 a3, .b.3 b3, .fa2.carry c_in} full_adder fa3,
+  {.fa0.sum 0, .fa1.sum 1, .fa2.sum 2, .fa3.sum 3} sum,
+  .fa3.carry overflow
+};
+
+-- VHDL: Full adder component
+full_adder = ${bit a, bit b, bit c_in} {
+  {.a a_val, .b b_val} xor_gate ab_xor,
+  {.ab_xor xor_val, .c_in c_val} xor_gate sum,
+  {.a a_val, .b b_val} and_gate ab_and,
+  {.ab_xor xor_val, .c_in c_val} and_gate xor_cin_and,
+  {.ab_and and1, .xor_cin_and and2} or_gate carry
+};

package/README.md

@@ -55,8 +55,8 @@ from `x` to `y` and recurses. When that no longer applies, it returns `y`.
 In the REPL:
 
 ```text
-> { {} |0 inc inc x, {} |0 inc y } add
-{}|0|+1|+1|+1 ?<X0 +1, {} 0, ...>=X0
+> { 0 inc inc x, 0 inc y } add
+{}|0|+1|+1|+1 ?<X0 +1, {} 0>=X0
 ```
 
 That evaluates `2 + 1` to `3`: a value starts at `0`, and each `+1` tag adds
@@ -195,6 +195,14 @@ Installed binary names are `k-` plus the source basename without `.mjs`, except
 for `k.mjs` itself. Source names that already include `k-`, such as
 `codecs/k-parse.mjs`, keep that name.
 
+## WebAssembly Backend
+
+The experimental WebAssembly backend lives in the separate
+[`fraczak/k-wasm`](https://github.com/fraczak/k-wasm) repository. Keeping the
+backend separate avoids adding its WABT dependency to the core runtime. External
+backends integrate with the compiler and binary codecs through
+[`backend-api.mjs`](backend-api.mjs).
+
 ## Node.js API
 
 ```js
@@ -277,13 +285,14 @@ compose with `.result` when only the floating-point value is needed.
 
 ```bash
 npm run prepare   # regenerate parsers from .jison grammars
-npm test          # run the full suite
+npm test          # run the fail-fast full suite with per-test timings
 ```
 
-The test suite covers:
+The test runner prints each test before execution and reports its elapsed time
+afterward. It stops immediately when a test fails. The suite covers:
 
 - core runtime and parser behavior
-- type derivation cases in `Code-derivation-tests/`
+- type derivation cases in `tests/code-derivation/`
 - hash/fingerprint stability
 - object file round-trips
 - REPL scripted interaction

package/backend-api.mjs

@@ -0,0 +1,12 @@
+export { annotate } from "./index.mjs";
+export { lowerToKVM, executeKVM } from "./kvm.mjs";
+export { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
+export { exportPatternGraph, NODE_KIND } from "./codecs/runtime/codec.mjs";
+export { patternToPropertyList, propertyListToPattern } from "./codecs/runtime/pattern-json.mjs";
+export { Product, Variant, fromObject } from "./Value.mjs";
+export { decodeObject, loadLibrary } from "./object.mjs";
+export { createState, evaluateInput } from "./repl.mjs";
+export { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";
+export { valueForCode } from "./repl-codecs.mjs";
+export { default as codes } from "./codes.mjs";
+export { default as run, run_converged } from "./run.mjs";

package/codecs/runtime/codec.mjs

@@ -614,6 +614,7 @@ function refinePatternForValue(pattern, value) {
     }
 
     if (baseNode.kind === NODE_KIND.CLOSED_PRODUCT || baseNode.kind === NODE_KIND.OPEN_PRODUCT) {
+      result.kind = NODE_KIND.CLOSED_PRODUCT;
       const values = occurrences.get(patternNodeId) || [];
       const explicit = new Map(baseNode.edges.map((edge) => [edge.label, edge.target]));
       let labels = [...explicit.keys()].sort();

package/export.mjs

@@ -113,6 +113,16 @@ function theID(alias, rel, scc, name) {
 export function assignCanonicalNames(scc, rels, relAlias) {
   const newAlias = scc.reduce( (newAlias,relName) => {
     const relDef = rels[relName];
+    // Rehashing an imported recursive relation would create a wrapper around its canonical hash.
+    if (
+      relDef.def.op == "ref" &&
+      relDef.def.ref.startsWith("@") &&
+      rels[relDef.def.ref]?._library
+    ) {
+      rels[relName] = rels[relDef.def.ref];
+      newAlias[relName] = relDef.def.ref;
+      return newAlias;
+    }
     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);

package/k-vscode/README.md

@@ -16,6 +16,13 @@ unions).
   - Canonical content-addressed references: `@base58hash`
   - Quoted label strings: `"label"`, `'label'` (with escape sequences)
   - The `...` any/open pattern marker
+- **Code-definition backgrounds** applied uniformly from the opening `$` through
+  the terminating `;`
+- **Nested expression backgrounds** for filters and `$` code expressions inside
+  relations, with code-expression backgrounds layered over filter backgrounds
+- **k Contrast color theme** with:
+  - Separate foreground colors for type names, relation identifiers, labels, tags,
+    filter variables, canonical type names, and canonical relation names
 - **Snippets** for every common pattern (trigger via `Tab` after prefix):
 
 | Prefix | Inserts |
@@ -48,13 +55,15 @@ unions).
 
 1. Open the `k-vscode/` folder in VS Code.
 2. Press **F5** — this opens an Extension Development Host with the extension loaded.
+3. Expression backgrounds activate automatically. Run **Preferences: Color Theme**
+   and select **k Contrast** to use the bundled foreground token palette.
 
 ### Build and install a VSIX
 
 ```bash
 cd k-vscode
 npm install
-npx vsce package        # produces k-language-0.2.0.vsix
+npx vsce package --no-dependencies  # produces k-language-0.2.0.vsix
 ```
 
 Then in VS Code: **Extensions → ⋯ → Install from VSIX…** and select the generated file.

package/k-vscode/extension.js

@@ -0,0 +1,273 @@
+const vscode = require("vscode");
+
+const NAME_START = /[a-zA-Z0-9_+\-]/;
+const NAME_PART = /[a-zA-Z0-9_?!+\-]/;
+const OPEN_TO_CLOSE = new Map([
+  ["{", "}"],
+  ["<", ">"],
+  ["(", ")"]
+]);
+const CLOSERS = new Set(OPEN_TO_CLOSE.values());
+
+function lex(text) {
+  const tokens = [];
+  let index = 0;
+
+  while (index < text.length) {
+    const char = text[index];
+    const next = text[index + 1];
+
+    if (/\s/.test(char)) {
+      index++;
+      continue;
+    }
+
+    if (char === "/" && next === "*") {
+      const end = text.indexOf("*/", index + 2);
+      index = end === -1 ? text.length : end + 2;
+      continue;
+    }
+
+    if (
+      (char === "/" && next === "/") ||
+      (char === "-" && next === "-") ||
+      (char === "\\" && next === "\\") ||
+      char === "#" ||
+      char === "%"
+    ) {
+      const end = text.indexOf("\n", index + 1);
+      index = end === -1 ? text.length : end + 1;
+      continue;
+    }
+
+    if (char === "\"" || char === "'") {
+      const start = index++;
+      while (index < text.length) {
+        const current = text[index++];
+        if (current === "\\") {
+          index++;
+        } else if (current === char) {
+          break;
+        }
+      }
+      tokens.push({ value: text.slice(start, index), start, end: index });
+      continue;
+    }
+
+    if (NAME_START.test(char)) {
+      const start = index++;
+      while (index < text.length && NAME_PART.test(text[index])) index++;
+      tokens.push({ value: text.slice(start, index), start, end: index });
+      continue;
+    }
+
+    tokens.push({ value: char, start: index, end: index + 1 });
+    index++;
+  }
+
+  return tokens;
+}
+
+function isName(token) {
+  return token != null && NAME_START.test(token.value[0]);
+}
+
+function findDefinitionEnd(tokens, startIndex) {
+  const stack = [];
+
+  for (let index = startIndex; index < tokens.length; index++) {
+    const value = tokens[index].value;
+    const closer = OPEN_TO_CLOSE.get(value);
+    if (closer) {
+      stack.push(closer);
+    } else if (CLOSERS.has(value)) {
+      if (value !== stack.at(-1)) return -1;
+      stack.pop();
+    } else if (value === ";" && stack.length === 0) {
+      return index;
+    }
+  }
+
+  return -1;
+}
+
+function findMatching(tokens, startIndex) {
+  const firstCloser = OPEN_TO_CLOSE.get(tokens[startIndex]?.value);
+  if (!firstCloser) return -1;
+
+  const stack = [firstCloser];
+  for (let index = startIndex + 1; index < tokens.length; index++) {
+    const value = tokens[index].value;
+    const closer = OPEN_TO_CLOSE.get(value);
+    if (closer) {
+      stack.push(closer);
+    } else if (CLOSERS.has(value)) {
+      if (value !== stack.at(-1)) return -1;
+      stack.pop();
+      if (stack.length === 0) return index;
+    }
+  }
+
+  return -1;
+}
+
+function parseCodeEnd(tokens, startIndex) {
+  const token = tokens[startIndex];
+  if (!token) return -1;
+
+  if (isName(token)) return startIndex + 1;
+
+  if (token.value === "@" && isName(tokens[startIndex + 1])) {
+    return startIndex + 2;
+  }
+
+  if (token.value === "{" || token.value === "<") {
+    const matching = findMatching(tokens, startIndex);
+    return matching === -1 ? -1 : matching + 1;
+  }
+
+  return -1;
+}
+
+function parseFilterEnd(tokens, startIndex) {
+  const token = tokens[startIndex];
+  if (!token) return -1;
+
+  let endIndex;
+  if (token.value === "$") {
+    endIndex = parseCodeEnd(tokens, startIndex + 1);
+  } else if (token.value === "(" || token.value === "{" || token.value === "<") {
+    const matching = findMatching(tokens, startIndex);
+    endIndex = matching === -1 ? -1 : matching + 1;
+  } else if (isName(token)) {
+    endIndex = startIndex + 1;
+  } else {
+    return -1;
+  }
+
+  if (
+    endIndex !== -1 &&
+    tokens[endIndex]?.value === "=" &&
+    isName(tokens[endIndex + 1])
+  ) {
+    endIndex += 2;
+  }
+
+  return endIndex;
+}
+
+function collectBackgroundRanges(text) {
+  const tokens = lex(text);
+  const type = [];
+  const filter = [];
+
+  let index = tokens[0]?.value === "~" ? 1 : 0;
+  while (index < tokens.length) {
+    const isTypeDefinition =
+      tokens[index]?.value === "$" &&
+      isName(tokens[index + 1]) &&
+      tokens[index + 2]?.value === "=";
+    const isRelationDefinition =
+      isName(tokens[index]) &&
+      tokens[index + 1]?.value === "=";
+
+    if (!isTypeDefinition && !isRelationDefinition) break;
+
+    const equalsIndex = index + (isTypeDefinition ? 2 : 1);
+    const endIndex = findDefinitionEnd(tokens, equalsIndex + 1);
+    if (endIndex === -1) break;
+
+    if (isTypeDefinition) {
+      type.push({
+        start: tokens[index].start,
+        end: tokens[endIndex].end
+      });
+    }
+    index = endIndex + 1;
+  }
+
+  for (let tokenIndex = 0; tokenIndex < tokens.length; tokenIndex++) {
+    if (tokens[tokenIndex].value === "?") {
+      const endIndex = parseFilterEnd(tokens, tokenIndex + 1);
+      if (endIndex !== -1) {
+        filter.push({
+          start: tokens[tokenIndex].start,
+          end: tokens[endIndex - 1].end
+        });
+      }
+      continue;
+    }
+
+    if (tokens[tokenIndex].value !== "$") continue;
+
+    const isDefinition =
+      isName(tokens[tokenIndex + 1]) &&
+      tokens[tokenIndex + 2]?.value === "=";
+    if (isDefinition) continue;
+
+    const endIndex = parseCodeEnd(tokens, tokenIndex + 1);
+    if (endIndex !== -1) {
+      type.push({
+        start: tokens[tokenIndex].start,
+        end: tokens[endIndex - 1].end
+      });
+    }
+  }
+
+  return { type, filter };
+}
+
+function toVscodeRanges(document, ranges) {
+  return ranges.map(({ start, end }) => new vscode.Range(
+    document.positionAt(start),
+    document.positionAt(end)
+  ));
+}
+
+function activate(context) {
+  const filterDecoration = vscode.window.createTextEditorDecorationType({
+    backgroundColor: "rgba(58, 45, 32, 0.82)"
+  });
+  const typeDecoration = vscode.window.createTextEditorDecorationType({
+    backgroundColor: "rgba(38, 53, 39, 0.92)"
+  });
+
+  context.subscriptions.push(filterDecoration, typeDecoration);
+
+  function updateEditor(editor) {
+    if (editor.document.languageId !== "k") return;
+
+    const ranges = collectBackgroundRanges(editor.document.getText());
+    editor.setDecorations(
+      filterDecoration,
+      toVscodeRanges(editor.document, ranges.filter)
+    );
+    editor.setDecorations(
+      typeDecoration,
+      toVscodeRanges(editor.document, ranges.type)
+    );
+  }
+
+  function updateVisibleEditors() {
+    for (const editor of vscode.window.visibleTextEditors) updateEditor(editor);
+  }
+
+  context.subscriptions.push(
+    vscode.window.onDidChangeVisibleTextEditors(updateVisibleEditors),
+    vscode.workspace.onDidChangeTextDocument(({ document }) => {
+      for (const editor of vscode.window.visibleTextEditors) {
+        if (editor.document === document) updateEditor(editor);
+      }
+    })
+  );
+
+  updateVisibleEditors();
+}
+
+function deactivate() {}
+
+module.exports = {
+  activate,
+  collectBackgroundRanges,
+  deactivate
+};

package/k-vscode/package.json

@@ -23,6 +23,21 @@
   "categories": [
     "Programming Languages"
   ],
+  "main": "./extension.js",
+  "activationEvents": [
+    "onLanguage:k"
+  ],
+  "files": [
+    "extension.js",
+    "language-configuration.json",
+    "README.md",
+    "snippets/k.json",
+    "syntaxes/k.tmLanguage.json",
+    "themes/k-contrast-color-theme.json"
+  ],
+  "scripts": {
+    "test": "node test/background-ranges.test.js"
+  },
   "contributes": {
     "languages": [
       {
@@ -44,6 +59,13 @@
         "path": "./syntaxes/k.tmLanguage.json"
       }
     ],
+    "themes": [
+      {
+        "label": "k Contrast",
+        "uiTheme": "vs-dark",
+        "path": "./themes/k-contrast-color-theme.json"
+      }
+    ],
     "snippets": [
       {
         "language": "k",