@fraczak/k 5.1.2 → 6.0.0

package/k-vscode/snippets/k.json

@@ -0,0 +1,92 @@
+{
+  "Code definition (union)": {
+    "prefix": "codeunion",
+    "body": ["\\$ ${1:name} = < ${2:type1} ${3:tag1}, ${4:type2} ${5:tag2} >;"],
+    "description": "Named code (type) using a tagged union"
+  },
+  "Code definition (product)": {
+    "prefix": "codeprod",
+    "body": ["\\$ ${1:name} = { ${2:type1} ${3:label1}, ${4:type2} ${5:label2} };"],
+    "description": "Named code (type) using a product (record)"
+  },
+  "Code definition (recursive union)": {
+    "prefix": "coderecunion",
+    "body": [
+      "\\$ ${1:name} = <",
+      "  {} ${2:base_tag},",
+      "  { ${1:name} ${3:field} } ${4:rec_tag}",
+      ">;"
+    ],
+    "description": "Recursive named code as a tagged union (e.g. nat, list)"
+  },
+  "Function definition": {
+    "prefix": "fn",
+    "body": ["${1:name} = ${2:expr};"],
+    "description": "Function/relation definition"
+  },
+  "Composition": {
+    "prefix": "comp",
+    "body": ["(${1:f} ${2:g})"],
+    "description": "Function composition: apply f then g"
+  },
+  "Merge": {
+    "prefix": "merge",
+    "body": ["< ${1:f}, ${2:g} >"],
+    "description": "Merge: try f first, fall back to g"
+  },
+  "Product combinator": {
+    "prefix": "prod",
+    "body": ["{ ${1:f} ${2:label1}, ${3:g} ${4:label2} }"],
+    "description": "Product combinator: apply functions in parallel, collect into a record"
+  },
+  "Filter (union)": {
+    "prefix": "filtunion",
+    "body": ["?< ${1:type1} ${2:tag1}, ${3:type2} ${4:tag2} > = ${5:X}"],
+    "description": "Filter expression constraining a union type, binding the subtype variable"
+  },
+  "Filter (product)": {
+    "prefix": "filtprod",
+    "body": ["?{ ${1:Type} ${2:field}, ${3:...} } = ${4:X}"],
+    "description": "Filter expression constraining a product type, binding the subtype variable"
+  },
+  "Product projection": {
+    "prefix": "dot",
+    "body": [".${1:field}"],
+    "description": "Product field projection: .field"
+  },
+  "Union tag projection": {
+    "prefix": "slash",
+    "body": ["/${1:tag}"],
+    "description": "Union tag projection (assert and unwrap): /tag"
+  },
+  "Variant introduction": {
+    "prefix": "vid",
+    "body": ["|${1:tag}"],
+    "description": "Variant (tagged union) introduction: |tag"
+  },
+  "Type annotation": {
+    "prefix": "typeref",
+    "body": ["\\$${1:typename}"],
+    "description": "Type annotation: pin expression output to a named code"
+  },
+  "Typed input constraint": {
+    "prefix": "typedprod",
+    "body": ["\\${ ${1:type1} ${2:field1}, ${3:type2} ${4:field2} }"],
+    "description": "Typed product input constraint: ${ type label, ... }"
+  },
+  "Identity": {
+    "prefix": "id",
+    "body": ["()"],
+    "description": "Identity function: pass value through unchanged"
+  },
+  "Empty product (unit leaf)": {
+    "prefix": "unit",
+    "body": ["{}"],
+    "description": "Empty product: the only leaf value in non-recursive definitions"
+  },
+  "Always undefined": {
+    "prefix": "undef",
+    "body": ["<>"],
+    "description": "Empty merge: always undefined (bottom)"
+  }
+}

package/k-vscode/syntaxes/k.tmLanguage.json

@@ -0,0 +1,243 @@
+{
+  "$schema": "https://raw.githubusercontent.com/martinring/tmlanguage/master/tmlanguage.json",
+  "name": "k",
+  "scopeName": "source.k",
+  "patterns": [
+    { "include": "#comment-block" },
+    { "include": "#comment-line" },
+    { "include": "#type-definition" },
+    { "include": "#function-definition" },
+    { "include": "#filter" },
+    { "include": "#type-ref" },
+    { "include": "#canonical-ref" },
+    { "include": "#projection-dot" },
+    { "include": "#projection-slash" },
+    { "include": "#variant-intro" },
+    { "include": "#string-double" },
+    { "include": "#string-single" },
+    { "include": "#dots" },
+    { "include": "#operators" },
+    { "include": "#brackets" }
+  ],
+  "repository": {
+
+    "comment-block": {
+      "name": "comment.block.k",
+      "begin": "/\\*",
+      "end": "\\*/",
+      "beginCaptures": { "0": { "name": "punctuation.definition.comment.k" } },
+      "endCaptures":   { "0": { "name": "punctuation.definition.comment.k" } }
+    },
+
+    "comment-line": {
+      "name": "comment.line.k",
+      "match": "(?://|--|%|#).*$"
+    },
+
+    "type-definition": {
+      "comment": "$ name = ... ; — defines a named code (type)",
+      "match": "(\\$)\\s*([a-zA-Z0-9_+\\-][a-zA-Z0-9_?!+\\-]*)(?=\\s*=)",
+      "captures": {
+        "1": { "name": "keyword.operator.type.k" },
+        "2": { "name": "entity.name.type.k" }
+      }
+    },
+
+    "function-definition": {
+      "comment": "name = ... ; — top-level function/relation definition",
+      "match": "^\\s*([a-zA-Z_][a-zA-Z0-9_?!+\\-]*)\\s*(?==)",
+      "captures": {
+        "1": { "name": "entity.name.function.k" }
+      }
+    },
+
+    "filter": {
+      "comment": "? introduces a filter/pattern constraint: ?<...>=X, ?{...}=X",
+      "patterns": [
+        {
+          "comment": "filter union ?< ... > = X",
+          "begin": "(\\?)\\s*(<)",
+          "end": "(>)(?:\\s*(=)\\s*([a-zA-Z0-9_?!+\\-]+))?",
+          "beginCaptures": {
+            "1": { "name": "keyword.operator.filter.k" },
+            "2": { "name": "punctuation.brackets.k" }
+          },
+          "endCaptures": {
+            "1": { "name": "punctuation.brackets.k" },
+            "2": { "name": "keyword.operator.filter.k" },
+            "3": { "name": "variable.other.pattern.k" }
+          },
+          "patterns": [
+            { "include": "#comment-block" },
+            { "include": "#comment-line" },
+            { "include": "#filter" },
+            { "include": "#pattern-variable" },
+            { "include": "#type-ref" },
+            { "include": "#string-double" },
+            { "include": "#string-single" },
+            { "include": "#dots" },
+            { "include": "#operators" },
+            { "include": "#brackets" }
+          ]
+        },
+        {
+          "comment": "filter product ?{ ... } = X",
+          "begin": "(\\?)\\s*(\\{)",
+          "end": "(\\})(?:\\s*(=)\\s*([a-zA-Z0-9_?!+\\-]+))?",
+          "beginCaptures": {
+            "1": { "name": "keyword.operator.filter.k" },
+            "2": { "name": "punctuation.brackets.k" }
+          },
+          "endCaptures": {
+            "1": { "name": "punctuation.brackets.k" },
+            "2": { "name": "keyword.operator.filter.k" },
+            "3": { "name": "variable.other.pattern.k" }
+          },
+          "patterns": [
+            { "include": "#comment-block" },
+            { "include": "#comment-line" },
+            { "include": "#filter" },
+            { "include": "#pattern-variable" },
+            { "include": "#type-ref" },
+            { "include": "#string-double" },
+            { "include": "#string-single" },
+            { "include": "#dots" },
+            { "include": "#operators" },
+            { "include": "#brackets" }
+          ]
+        }
+      ]
+    },
+
+    "pattern-variable": {
+      "comment": "Uppercase identifiers used as pattern variables inside filter expressions",
+      "name": "variable.other.pattern.k",
+      "match": "\\b[A-Z][a-zA-Z0-9_]*\\b"
+    },
+
+    "type-ref": {
+      "comment": "$name — use of a named code as a type annotation or type expression",
+      "match": "(\\$)([a-zA-Z0-9_+\\-][a-zA-Z0-9_?!+\\-]*)?",
+      "captures": {
+        "1": { "name": "keyword.operator.type.k" },
+        "2": { "name": "storage.type.k" }
+      }
+    },
+
+    "canonical-ref": {
+      "comment": "@base58hash — content-addressed canonical code reference",
+      "name": "variable.other.constant.k",
+      "match": "@[a-zA-Z0-9]+"
+    },
+
+    "projection-dot": {
+      "comment": ".label or .\"label\" — product field projection",
+      "patterns": [
+        {
+          "name": "keyword.operator.projection.k",
+          "match": "\\.(?:[a-zA-Z0-9_+\\-][a-zA-Z0-9_?!+\\-]*)"
+        },
+        {
+          "begin": "\\.(\")",
+          "end": "\"",
+          "beginCaptures": { "0": { "name": "keyword.operator.projection.k" } },
+          "endCaptures":   { "0": { "name": "keyword.operator.projection.k" } },
+          "contentName": "string.quoted.double.k"
+        },
+        {
+          "begin": "\\.(\')",
+          "end": "\'",
+          "beginCaptures": { "0": { "name": "keyword.operator.projection.k" } },
+          "endCaptures":   { "0": { "name": "keyword.operator.projection.k" } },
+          "contentName": "string.quoted.single.k"
+        }
+      ]
+    },
+
+    "projection-slash": {
+      "comment": "/tag or /\"tag\" — union tag projection (assert and unwrap)",
+      "patterns": [
+        {
+          "name": "keyword.operator.projection.k",
+          "match": "/(?:[a-zA-Z0-9_+\\-][a-zA-Z0-9_?!+\\-]*)"
+        },
+        {
+          "begin": "/(\")",
+          "end": "\"",
+          "beginCaptures": { "0": { "name": "keyword.operator.projection.k" } },
+          "endCaptures":   { "0": { "name": "keyword.operator.projection.k" } },
+          "contentName": "string.quoted.double.k"
+        },
+        {
+          "begin": "/(\')",
+          "end": "\'",
+          "beginCaptures": { "0": { "name": "keyword.operator.projection.k" } },
+          "endCaptures":   { "0": { "name": "keyword.operator.projection.k" } },
+          "contentName": "string.quoted.single.k"
+        }
+      ]
+    },
+
+    "variant-intro": {
+      "comment": "|tag or |\"tag\" — variant (tagged union) introduction",
+      "patterns": [
+        {
+          "name": "keyword.operator.intro.k",
+          "match": "\\|[a-zA-Z0-9_+\\-][a-zA-Z0-9_?!+\\-]*"
+        },
+        {
+          "begin": "\\|(\")",
+          "end": "\"",
+          "beginCaptures": { "0": { "name": "keyword.operator.intro.k" } },
+          "endCaptures":   { "0": { "name": "keyword.operator.intro.k" } },
+          "contentName": "string.quoted.double.k"
+        },
+        {
+          "begin": "\\|(\')",
+          "end": "\'",
+          "beginCaptures": { "0": { "name": "keyword.operator.intro.k" } },
+          "endCaptures":   { "0": { "name": "keyword.operator.intro.k" } },
+          "contentName": "string.quoted.single.k"
+        }
+      ]
+    },
+
+    "string-double": {
+      "name": "string.quoted.double.k",
+      "begin": "\"",
+      "end": "\"",
+      "patterns": [
+        { "name": "constant.character.escape.k", "match": "\\\\(?:[\"\\\\/bfnrt]|u[0-9a-fA-F]{4})" },
+        { "name": "invalid.illegal.escape.k",    "match": "\\\\." }
+      ]
+    },
+
+    "string-single": {
+      "name": "string.quoted.single.k",
+      "begin": "'",
+      "end": "'",
+      "patterns": [
+        { "name": "constant.character.escape.k", "match": "\\\\(?:['\\\\/bfnrt]|u[0-9a-fA-F]{4})" },
+        { "name": "invalid.illegal.escape.k",    "match": "\\\\." }
+      ]
+    },
+
+    "dots": {
+      "comment": "... — the any/open pattern (unconstrained position)",
+      "name": "constant.language.k",
+      "match": "\\.\\.\\."
+    },
+
+    "operators": {
+      "comment": "= ; , : ~ — structural separators and definition operators",
+      "name": "punctuation.separator.k",
+      "match": "[=;,:]|~"
+    },
+
+    "brackets": {
+      "comment": "{ } ( ) < > — grouping and combinator delimiters",
+      "name": "punctuation.brackets.k",
+      "match": "[{}()<>]"
+    }
+  }
+}

package/k.mjs

@@ -2,77 +2,79 @@
 // !/usr/bin/node --stack-size=8000
 
 import fs from "node:fs";
+import { argv, stdin, exit, stdout } from "node:process";
 import k from "./index.mjs";
+import { decodeWire, encodeToWire } from "./codecs/runtime/prefix-codec.mjs";
+import { decodeObject, objectToFunction, loadLibrary } from "./object.mjs";
 
-const prog = process.argv[1];
+const prog = argv[1];
 
-let kScript, jsonStream, oneJson;
+let kScript, inputStream;
 
-({ kScript, jsonStream, oneJson } = ((oneJson, args) => {
-  let e;
+function usage() {
+  console.error(`Usage: ${prog} [ --lib lib-file ]... ( k-expr | -k file ) [ input-file ]`);
+  console.error(`       E.g.,  echo '["zebara","ela"]' | ./codecs/k-parse.mjs --input-type '$x=<{} zebara, {} ela>; $v={x 0, x 1}; $v' | ${prog} '{.1 0}'`);
+}
+
+function compileFile(path, libraries) {
+  const buffer = fs.readFileSync(path);
+  try {
+    return objectToFunction(decodeObject(buffer));
+  } catch {
+    return k.compile(buffer.toString("utf8"), { libraries });
+  }
+}
+
+({ kScript, inputStream } = ((args) => {
   try {
-    kScript = (function (arg) {
+    const libraries = [];
+    // Parse --lib flags
+    while (args.length > 0 && 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)));
+    }
+
+    let kScriptStr = (function (arg) {
       if (arg == null) {
-        throw new Error();
+        throw new Error("Missing script argument");
       }
       if (arg === "-k") {
-        return fs.readFileSync(args.shift()).toString("utf8");
+        return compileFile(args.shift(), libraries);
       } else {
         return arg;
       }
     })(args.shift());
-    kScript = k.compile(kScript);
-    jsonStream = (function (arg) {
-      if (arg === "-1") {
-        oneJson = true;
-        arg = args.shift();
-      }
+    let kScript = typeof kScriptStr === "function" ? kScriptStr : k.compile(kScriptStr, { libraries });
+    inputStream = (function (arg) {
       if (arg == null) {
-        return process.stdin;
+        return stdin;
       }
       return fs.createReadStream(arg);
     })(args.shift());
-    return { kScript, jsonStream, oneJson };
+    return { kScript, inputStream };
   } catch (error) {
-    e = error;
-    console.error(e);
-    console.error(`Usage: ${prog} ( k-expr | -k k-file ) [ -1 ] [ json-file ]`);
-    console.error(`       E.g.,  echo '{\"a\": 12}' | ${prog} '[(),()]'`);
-    return process.exit(-1);
+    console.error(error);
+    usage();
+    return exit(-1);
   }
-})(false, process.argv.slice(2)));
+})(argv.slice(2)));
 
-if (oneJson) {
-  const buffer = [];
-  jsonStream.on("data", (data) => buffer.push(data));
-  jsonStream.on("end", () => {
-    try {
-      console.log(JSON.stringify(kScript(JSON.parse(buffer.join(""))), null, 2));
-    } catch (error) {
-      console.error(error);
-    }
-  });
-} else {
-  let buffer = [];
-  let line = 0;
-  jsonStream.on("data", (data) => {
-    const [first, ...rest] = data.toString("utf8").split("\n");
-    buffer.push(first);
-    if (rest.length > 0) {
-      const todo = buffer.join("");
-      const last = rest.pop();
-      buffer = [last];;
-      for (const exp of [todo, ...rest]) {
-        if (!exp.match(/^[ \n\t]*(?:#.*)?$/)) {
-          try {
-            console.log(JSON.stringify(kScript(JSON.parse(exp))));
-          } catch (error) {
-            console.error(`Problem [line ${line}]: '${exp}'`);
-            console.error(error);
-          }
-        }
-        line++;
-      }
+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 result = kScript(value);
+    if (result === undefined) {
+      throw new Error("k expression evaluated to undefined; cannot encode undefined output value");
     }
-  });
-}
+    stdout.write(encodeToWire(result, result.pattern));
+  } catch (error) {
+    console.error(error);
+    process.exitCode = 1;
+  }
+});