@fraczak/k 6.1.3 → 6.2.1

package/k-vscode/test/background-ranges.test.js

@@ -0,0 +1,50 @@
+const assert = require("assert");
+const Module = require("module");
+
+const originalLoad = Module._load;
+Module._load = function load(request, parent, isMain) {
+  if (request === "vscode") return {};
+  return originalLoad.call(this, request, parent, isMain);
+};
+
+const { collectBackgroundRanges } = require("../extension");
+
+function slices(text, ranges) {
+  return ranges.map(({ start, end }) => text.slice(start, end));
+}
+
+const source = [
+  "$ pair = { leaf left, leaf right };",
+  "pick = $pair ?{<$leaf some, ...>=X branch, ...} .branch;",
+  "-- ?<ignored tag>",
+  "/* $ignored */",
+  "$pair pick"
+].join("\n");
+
+const ranges = collectBackgroundRanges(source);
+const type = slices(source, ranges.type);
+const filter = slices(source, ranges.filter);
+
+assert.deepStrictEqual(type, [
+  "$ pair = { leaf left, leaf right };",
+  "$pair",
+  "$leaf",
+  "$pair"
+]);
+assert.deepStrictEqual(filter, ["?{<$leaf some, ...>=X branch, ...}"]);
+
+const nested = "add = ?{ $nat x, ... } = X <{.x pred x, .y succ y} ? X add, .y> ;";
+const nestedRanges = collectBackgroundRanges(nested);
+
+assert.deepStrictEqual(slices(nested, nestedRanges.filter), [
+  "?{ $nat x, ... } = X",
+  "? X"
+]);
+assert.deepStrictEqual(slices(nested, nestedRanges.type), ["$nat"]);
+assert.deepStrictEqual(nestedRanges.filter, [
+  { start: 6, end: 26 },
+  { start: 51, end: 54 }
+]);
+assert.deepStrictEqual(nestedRanges.type, [{ start: 9, end: 13 }]);
+
+console.log("background range scanner tests passed");

package/k-vscode/themes/k-contrast-color-theme.json

@@ -0,0 +1,104 @@
+{
+  "$schema": "vscode://schemas/color-theme",
+  "name": "k Contrast",
+  "type": "dark",
+  "colors": {
+    "editor.background": "#161B22",
+    "editor.foreground": "#C9D1D9",
+    "editorLineNumber.foreground": "#6E7681",
+    "editorLineNumber.activeForeground": "#C9D1D9",
+    "editor.selectionBackground": "#264F78",
+    "editor.inactiveSelectionBackground": "#264F7855"
+  },
+  "tokenColors": [
+    {
+      "scope": [
+        "comment.block.k",
+        "comment.line.k"
+      ],
+      "settings": {
+        "foreground": "#8B949E",
+        "fontStyle": "italic"
+      }
+    },
+    {
+      "scope": "entity.name.type.k",
+      "settings": {
+        "foreground": "#FF7B72",
+        "fontStyle": "bold"
+      }
+    },
+    {
+      "scope": "support.type.k",
+      "settings": {
+        "foreground": "#FFA657"
+      }
+    },
+    {
+      "scope": "support.function.identifier.k",
+      "settings": {
+        "foreground": "#79C0FF"
+      }
+    },
+    {
+      "scope": "support.type.canonical.k",
+      "settings": {
+        "foreground": "#F778BA"
+      }
+    },
+    {
+      "scope": "support.function.canonical.k",
+      "settings": {
+        "foreground": "#FF967D"
+      }
+    },
+    {
+      "scope": "entity.name.label.k",
+      "settings": {
+        "foreground": "#7EE787"
+      }
+    },
+    {
+      "scope": "entity.name.tag.k",
+      "settings": {
+        "foreground": "#F2CC60"
+      }
+    },
+    {
+      "scope": "variable.other.pattern.k",
+      "settings": {
+        "foreground": "#56D4DD"
+      }
+    },
+    {
+      "scope": [
+        "keyword.operator.assignment.k",
+        "keyword.operator.binding.k",
+        "keyword.operator.filter.k",
+        "keyword.operator.projection.product.k",
+        "keyword.operator.projection.union.k",
+        "keyword.operator.type.k",
+        "keyword.operator.variant.k"
+      ],
+      "settings": {
+        "foreground": "#FFDF5D"
+      }
+    },
+    {
+      "scope": "punctuation.definition.canonical.k",
+      "settings": {
+        "foreground": "#B392F0"
+      }
+    },
+    {
+      "scope": [
+        "constant.language.any.k",
+        "string.quoted.double.k",
+        "string.quoted.single.k"
+      ],
+      "settings": {
+        "foreground": "#A5D6FF"
+      }
+    }
+  ]
+}

package/kvm.mjs

@@ -0,0 +1,523 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import { argv, stdin, exit, stdout } from "node:process";
+import { Product, Variant, composePattern, withPattern } from "./Value.mjs";
+import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
+import {
+  constrainWithPattern,
+  intersectPatterns,
+  projectionPattern,
+  verify,
+  run
+} from "./run.mjs";
+import { annotate } from "./index.mjs";
+import { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
+import { decodeObject, loadLibrary } from "./object.mjs";
+import codes from "./codes.mjs";
+import { isMainEntrypoint } from "./codecs/runtime/cli-entry.mjs";
+
+class KVMBuilder {
+  constructor(typePatternGraph) {
+    this.typePatternGraph = typePatternGraph;
+    this.regCount = 0;
+    this.instructions = [];
+  }
+
+  nextReg() {
+    return `%v${this.regCount++}`;
+  }
+
+  emit(inst) {
+    this.instructions.push(inst);
+  }
+
+  getStaticPattern(exp, index) {
+    if (!this.typePatternGraph || !exp.patterns) return null;
+    const patternId = this.typePatternGraph.find(exp.patterns[index]);
+    return patternToPropertyList(exportPatternGraph(this.typePatternGraph, patternId));
+  }
+}
+
+function compile(exp, inputReg, builder) {
+  switch (exp.op) {
+    case "identity": {
+      const dest = builder.nextReg();
+      builder.emit({ op: "id", dest, src: inputReg });
+      return dest;
+    }
+    case "empty": {
+      builder.emit({ op: "fail" });
+      return builder.nextReg();
+    }
+    case "filter": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "guard_pattern",
+        dest,
+        src: inputReg,
+        pattern: builder.getStaticPattern(exp, 0),
+        exp
+      });
+      return dest;
+    }
+    case "code": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "guard_code",
+        dest,
+        src: inputReg,
+        code: exp.code,
+        exp
+      });
+      return dest;
+    }
+    case "dot": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "project_field",
+        dest,
+        src: inputReg,
+        label: exp.dot,
+        pattern: builder.getStaticPattern(exp, 1),
+        exp
+      });
+      return dest;
+    }
+    case "div": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "project_variant",
+        dest,
+        src: inputReg,
+        tag: exp.div,
+        pattern: builder.getStaticPattern(exp, 1),
+        exp
+      });
+      return dest;
+    }
+    case "vid": {
+      const dest = builder.nextReg();
+      builder.emit({
+        op: "make_variant",
+        dest,
+        tag: exp.vid,
+        src: inputReg
+      });
+      return dest;
+    }
+    case "ref": {
+      const dest = builder.nextReg();
+      if (exp.ref.startsWith("_")) {
+        builder.emit({
+          op: "call_intrinsic",
+          dest,
+          symbol: exp.ref,
+          src: inputReg,
+          pattern: builder.getStaticPattern(exp, 0),
+          exp
+        });
+      } else {
+        builder.emit({
+          op: "call",
+          dest,
+          func: exp.ref,
+          src: inputReg,
+          exp
+        });
+      }
+      return dest;
+    }
+    case "comp": {
+      let currentReg = inputReg;
+      const compInputPattern = builder.getStaticPattern(exp, 0);
+      if (compInputPattern) {
+        const guarded = builder.nextReg();
+        builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: compInputPattern, exp });
+        currentReg = guarded;
+      }
+      for (const subExp of exp.comp) {
+        currentReg = compile(subExp, currentReg, builder);
+      }
+      return currentReg;
+    }
+    case "product": {
+      const dest = builder.nextReg();
+      const branches = [];
+      for (const { label, exp: fieldExp } of exp.product) {
+        const branchBuilder = new KVMBuilder(builder.typePatternGraph);
+        const branchInput = "%in";
+        const branchOutput = compile(fieldExp, branchInput, branchBuilder);
+        branchBuilder.emit({ op: "return", src: branchOutput });
+        branches.push({
+          label,
+          body: branchBuilder.instructions
+        });
+      }
+      builder.emit({
+        op: "product",
+        dest,
+        src: inputReg,
+        branches,
+        pattern: builder.getStaticPattern(exp, 1),
+        exp
+      });
+      return dest;
+    }
+    case "union": {
+      const dest = builder.nextReg();
+      const branches = [];
+      for (const branchExp of exp.union) {
+        const branchBuilder = new KVMBuilder(builder.typePatternGraph);
+        const branchInput = "%in";
+        const branchOutput = compile(branchExp, branchInput, branchBuilder);
+        branchBuilder.emit({ op: "return", src: branchOutput });
+        branches.push({
+          body: branchBuilder.instructions
+        });
+      }
+      builder.emit({
+        op: "union",
+        dest,
+        src: inputReg,
+        branches,
+        exp
+      });
+      return dest;
+    }
+    default:
+      throw new Error(`Unsupported AST operation: ${exp.op}`);
+  }
+}
+
+export function lowerToKVM(relDef, name, options = {}) {
+  const typePatternGraph = relDef.typePatternGraph || null;
+  const builder = new KVMBuilder(typePatternGraph);
+  const inputReg = "%in";
+
+  let currentReg = inputReg;
+  const inputPattern = builder.getStaticPattern(relDef.def, 0);
+  if (inputPattern) {
+    const guarded = builder.nextReg();
+    builder.emit({ op: "guard_pattern", dest: guarded, src: currentReg, pattern: inputPattern, exp: relDef.def });
+    currentReg = guarded;
+  }
+
+  const bodyOutput = compile(relDef.def, currentReg, builder);
+
+  let finalReg = bodyOutput;
+  const outputPattern = builder.getStaticPattern(relDef.def, 1);
+  if (outputPattern) {
+    const guarded = builder.nextReg();
+    builder.emit({ op: "guard_pattern", dest: guarded, src: finalReg, pattern: outputPattern, exp: relDef.def });
+    finalReg = guarded;
+  }
+
+  builder.emit({ op: "return", src: finalReg });
+
+  return {
+    name,
+    inputPattern,
+    outputPattern,
+    isConverged: relDef.typeDerivation?.status === "converged",
+    body: builder.instructions
+  };
+}
+
+function executeBlock(instructions, inputVal, context) {
+  const registers = new Map();
+  registers.set("%in", inputVal);
+
+  for (const inst of instructions) {
+    const res = executeInstruction(inst, registers, context);
+    if (res === undefined) {
+      return undefined;
+    }
+    if (res.type === "return") {
+      return res.value;
+    }
+  }
+  return undefined;
+}
+
+function executeInstruction(inst, registers, context) {
+  const options = context.options || {};
+  switch (inst.op) {
+    case "id": {
+      registers.set(inst.dest, registers.get(inst.src));
+      return { type: "continue" };
+    }
+    case "fail": {
+      return undefined;
+    }
+    case "guard_pattern": {
+      const val = registers.get(inst.src);
+      if (options.envelopeFree) {
+        registers.set(inst.dest, val);
+        return { type: "continue" };
+      }
+      try {
+        const constrained = constrainWithPattern(val, inst.pattern, inst.exp);
+        registers.set(inst.dest, constrained);
+        return { type: "continue" };
+      } catch (err) {
+        if (err instanceof TypeError) {
+          throw err;
+        }
+        return undefined;
+      }
+    }
+    case "guard_code": {
+      const val = registers.get(inst.src);
+      if (options.envelopeFree) {
+        registers.set(inst.dest, val);
+        return { type: "continue" };
+      }
+      if (verify(context.findCode, inst.code, val)) {
+        registers.set(inst.dest, val);
+        return { type: "continue" };
+      }
+      return undefined;
+    }
+    case "project_field": {
+      const val = registers.get(inst.src);
+      if (!(val instanceof Product)) return undefined;
+      const fieldVal = val.product[inst.label];
+      if (fieldVal === undefined) return undefined;
+
+      if (options.envelopeFree) {
+        registers.set(inst.dest, fieldVal);
+      } else {
+        const pattern = projectionPattern(inst.pattern, val.pattern, inst.label, inst.exp);
+        registers.set(inst.dest, withPattern(fieldVal, pattern));
+      }
+      return { type: "continue" };
+    }
+    case "project_variant": {
+      const val = registers.get(inst.src);
+      if (!(val instanceof Variant) || val.tag !== inst.tag) return undefined;
+
+      if (options.envelopeFree) {
+        registers.set(inst.dest, val.value);
+      } else {
+        const pattern = projectionPattern(inst.pattern, val.pattern, inst.tag, inst.exp);
+        registers.set(inst.dest, withPattern(val.value, pattern));
+      }
+      return { type: "continue" };
+    }
+    case "make_variant": {
+      const val = registers.get(inst.src);
+      if (options.envelopeFree) {
+        registers.set(inst.dest, new Variant(inst.tag, val));
+      } else {
+        registers.set(
+          inst.dest,
+          new Variant(inst.tag, val, composePattern("open-union", [[inst.tag, val.pattern]]))
+        );
+      }
+      return { type: "continue" };
+    }
+    case "call": {
+      const val = registers.get(inst.src);
+      const relDef = context.rels[inst.func];
+      if (!relDef) {
+        throw new Error(`Unknown ref: '${inst.func}'`);
+      }
+      if (options.requireConverged && relDef.typeDerivation?.status !== "converged") {
+        throw new Error(`Cannot run '${inst.func}' without envelopes: type derivation is not converged`);
+      }
+      if (options.trace) {
+        console.log(`[Trace] Calling ${inst.func} with:`, val ? val.toString() : "null");
+      }
+      if (!relDef._kvmFunc) {
+        relDef._kvmFunc = lowerToKVM(relDef, inst.func);
+      }
+      const res = executeKVM(relDef._kvmFunc, val, context);
+      if (options.trace) {
+        console.log(`[Trace] Returned from ${inst.func} ->:`, res ? res.toString() : "fail");
+      }
+      if (res === undefined) return undefined;
+      registers.set(inst.dest, res);
+      return { type: "continue" };
+    }
+    case "call_intrinsic": {
+      const val = registers.get(inst.src);
+      const builtinFunc = run.builtin[inst.symbol];
+      if (!builtinFunc) {
+        throw new Error(`Unknown builtin: '${inst.symbol}'`);
+      }
+      if (!options.envelopeFree && inst.pattern) {
+        try {
+          const constrained = constrainWithPattern(val, inst.pattern, inst.exp);
+          const res = builtinFunc(constrained);
+          registers.set(inst.dest, res);
+          return { type: "continue" };
+        } catch (err) {
+          throw err;
+        }
+      } else {
+        const res = builtinFunc(val);
+        registers.set(inst.dest, res);
+        return { type: "continue" };
+      }
+    }
+    case "product": {
+      const val = registers.get(inst.src);
+      const result = {};
+      const patternEntries = [];
+      for (const branch of inst.branches) {
+        const branchRes = executeBlock(branch.body, val, context);
+        if (branchRes === undefined) return undefined;
+        result[branch.label] = branchRes;
+        if (!options.envelopeFree) {
+          patternEntries.push([branch.label, branchRes.pattern]);
+        }
+      }
+      let productValue;
+      if (options.envelopeFree) {
+        productValue = new Product(result);
+      } else {
+        const staticOutputPattern = inst.pattern;
+        if (staticOutputPattern) {
+          productValue = new Product(result, staticOutputPattern);
+        } else {
+          productValue = new Product(result, composePattern("closed-product", patternEntries));
+        }
+      }
+      registers.set(inst.dest, productValue);
+      return { type: "continue" };
+    }
+    case "union": {
+      const val = registers.get(inst.src);
+      for (const branch of inst.branches) {
+        const branchRes = executeBlock(branch.body, val, context);
+        if (branchRes !== undefined) {
+          registers.set(inst.dest, branchRes);
+          return { type: "continue" };
+        }
+      }
+      return undefined;
+    }
+    case "return": {
+      return { type: "return", value: registers.get(inst.src) };
+    }
+    default:
+      throw new Error(`Unknown instruction op: ${inst.op}`);
+  }
+}
+
+export function executeKVM(kvmFunc, inputVal, context) {
+  const options = context.options || {};
+  if (options.requireConverged && !kvmFunc.isConverged) {
+    throw new Error(`Cannot run '${kvmFunc.name}' without envelopes: type derivation is not converged`);
+  }
+
+  const result = executeBlock(kvmFunc.body, inputVal, context);
+  if (result === undefined) return undefined;
+
+  if (options.envelopeFree && kvmFunc.isConverged) {
+    return withPattern(result, kvmFunc.outputPattern);
+  }
+  return result;
+}
+
+export default {
+  lowerToKVM,
+  executeKVM
+};
+
+function usage() {
+  const prog = argv[1] || "kvm.mjs";
+  console.error(`Usage: node ${prog} [ options ] ( k-expr | -k file ) [ input-file ]`);
+  console.error("Options:");
+  console.error("  --lib file          Load a .klib dependency before compiling. May be repeated.");
+  console.error("  --envelope-free     Run the interpreter in envelope-free mode.");
+  console.error("  -h, --help          Show this help.");
+}
+
+async function main() {
+  const args = argv.slice(2);
+  if (args.includes("-h") || args.includes("--help")) {
+    usage();
+    return exit(0);
+  }
+
+  let envelopeFree = false;
+  const libraries = [];
+
+  // Parse options
+  while (args.length > 0) {
+    if (args[0] === "--envelope-free") {
+      envelopeFree = true;
+      args.shift();
+    } else if (args[0] === "--lib") {
+      args.shift();
+      const libPath = args.shift();
+      if (!libPath) throw new Error("--lib requires a file argument");
+      const libBuffer = fs.readFileSync(libPath);
+      libraries.push(loadLibrary(decodeObject(libBuffer)));
+    } else {
+      break;
+    }
+  }
+
+  let kScriptStr = (function (arg) {
+    if (arg == null) {
+      throw new Error("Missing script argument");
+    }
+    if (arg === "-k") {
+      const fileArg = args.shift();
+      if (!fileArg) throw new Error("-k requires a file argument");
+      return fs.readFileSync(fileArg, "utf8");
+    } else {
+      return arg;
+    }
+  })(args.shift());
+
+  const inputStream = (function (arg) {
+    if (arg == null) {
+      return stdin;
+    }
+    return fs.createReadStream(arg);
+  })(args.shift());
+
+  const defs = annotate(kScriptStr, { libraries });
+  const mainRel = defs.rels.__main__;
+  if (!mainRel) {
+    throw new Error("No main relation (__main__) defined in script");
+  }
+
+  const kvmFunc = lowerToKVM(mainRel, "__main__");
+
+  const buffer = [];
+  inputStream.on("data", (data) => buffer.push(Buffer.isBuffer(data) ? data : Buffer.from(data)));
+  inputStream.on("end", () => {
+    try {
+      const inputBuffer = Buffer.concat(buffer);
+      const { pattern: inputPattern, value } = decodeWire(inputBuffer);
+      const context = {
+        rels: defs.rels,
+        findCode: codes.find,
+        options: {
+          envelopeFree
+        }
+      };
+      const result = executeKVM(kvmFunc, value, context);
+      if (result === undefined) {
+        throw new Error("kVM expression evaluated to undefined");
+      }
+      stdout.write(encodeToWire(result, result.pattern));
+    } catch (error) {
+      console.error(error.stack || error.message || String(error));
+      exit(1);
+    }
+  });
+}
+
+if (isMainEntrypoint(import.meta.url, argv[1])) {
+  main().catch((error) => {
+    console.error(error.stack || error.message || String(error));
+    usage();
+    exit(1);
+  });
+}

package/package.json

@@ -1,11 +1,11 @@
 {
     "name": "@fraczak/k",
-    "version": "6.1.3",
+    "version": "6.2.1",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {
         "prepare": "jiwson -m es6 parser.jison -o parser.mjs; jiwson -m es6 valueParser.jison -o valueParser.mjs; ",
-        "test": "node test.mjs; for f in Code-derivation-tests/*.mjs; do echo $f; node $f; done; node test-fingerprint.mjs; node test-hash-fuzz.mjs; node test-hash-normalization.mjs; node test-k-object.mjs; node test-repl.mjs; node test-ieee-arithmetic.mjs; ./tests.sh",
+        "test": "node scripts/run-tests.mjs",
         "perf:idempotency": "node scripts/benchmark-idempotency.mjs",
         "deps:graph": "node scripts/generate-dependency-graph.mjs"
     },
@@ -30,7 +30,8 @@
         "k-show": "./codecs/show.mjs",
         "k-unit": "./codecs/unit.mjs",
         "k-utf16": "./codecs/utf16.mjs",
-        "k-utf8": "./codecs/utf8.mjs"
+        "k-utf8": "./codecs/utf8.mjs",
+        "k-vm": "./kvm.mjs"
     },
     "devDependencies": {
         "jiwson": "^0.1.2"