@fraczak/k 6.3.3 → 6.4.0

package/k-vscode/extension.js

@@ -1,273 +0,0 @@
-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/language-configuration.json

@@ -1,42 +0,0 @@
-{
-  "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

@@ -1,79 +0,0 @@
-{
-  "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"
-  ],
-  "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": [
-      {
-        "id": "k",
-        "aliases": [
-          "k language",
-          "k"
-        ],
-        "extensions": [
-          ".k"
-        ],
-        "configuration": "./language-configuration.json"
-      }
-    ],
-    "grammars": [
-      {
-        "language": "k",
-        "scopeName": "source.k",
-        "path": "./syntaxes/k.tmLanguage.json"
-      }
-    ],
-    "themes": [
-      {
-        "label": "k Contrast",
-        "uiTheme": "vs-dark",
-        "path": "./themes/k-contrast-color-theme.json"
-      }
-    ],
-    "snippets": [
-      {
-        "language": "k",
-        "path": "./snippets/k.json"
-      }
-    ]
-  },
-  "devDependencies": {
-    "@vscode/vsce": "^3.7.1"
-  }
-}

package/k-vscode/snippets/k.json

@@ -1,92 +0,0 @@
-{
-  "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)"
-  }
-}