@fraczak/k 6.1.1 → 6.1.3

package/test-ieee-arithmetic.mjs

@@ -0,0 +1,93 @@
+import assert from "node:assert/strict";
+
+import { createState, evaluateInput } from "./repl.mjs";
+import { Product } from "./Value.mjs";
+import codes from "./codes.mjs";
+import { parse as parseFloat64, print as printFloat64 } from "./codecs/ieee.mjs";
+import { singletonPatternToCodeHash, valueForCode } from "./repl-codecs.mjs";
+
+const state = createState();
+await evaluateInput(":load Examples/ieee.k", state);
+
+for (const name of ["add", "sub", "mul", "div"]) {
+  assert.ok(state.relAliases[name], `Expected public IEEE relation '${name}'`);
+}
+
+const float64Hash = state.typeAliases.float64;
+const floatPairHash = state.typeAliases.float_pair;
+
+function float64(text) {
+  return valueForCode(parseFloat64(text), float64Hash, codes.find);
+}
+
+function floatPair(x, y) {
+  return valueForCode(new Product({
+    x: float64(x),
+    y: float64(y)
+  }), floatPairHash, codes.find);
+}
+
+async function runOperation(op, x, y) {
+  state.value = floatPair(x, y);
+  await evaluateInput(op, state);
+  return state.value;
+}
+
+async function runProjectedResult(op, x, y) {
+  state.value = floatPair(x, y);
+  await evaluateInput(`${op}.result`, state);
+  return state.value;
+}
+
+function assertFloatResult(value, expected, label) {
+  assert.equal(singletonPatternToCodeHash(value.pattern), float64Hash, `${label}: result should keep float64 envelope`);
+  assert.equal(printFloat64(value), expected, label);
+}
+
+async function assertOperation({ op, x, y, result, flags = null }) {
+  const bundle = await runOperation(op, x, y);
+  assert.ok(bundle instanceof Product, `${op} should return a result bundle`);
+  assert.deepEqual(Object.keys(bundle.product).sort(), ["flags", "result"]);
+  assertFloatResult(bundle.product.result, result, `${op}(${x}, ${y}).result`);
+  if (flags != null) {
+    assert.equal(bundle.product.flags.tag, flags, `${op}(${x}, ${y}).flags`);
+  }
+
+  const projected = await runProjectedResult(op, x, y);
+  assertFloatResult(projected, result, `${op}(${x}, ${y}).result projection`);
+}
+
+const cases = [
+  // Addition: same sign, cancellation, exact fractional add, and specials.
+  { op: "add", x: "1", y: "1", result: "2", flags: "none" },
+  { op: "add", x: "-1", y: "1", result: "0", flags: "none" },
+  { op: "add", x: "0.5", y: "0.25", result: "0.75", flags: "none" },
+  { op: "add", x: "Infinity", y: "-Infinity", result: "NaN", flags: "invalid" },
+  { op: "add", x: "NaN", y: "1", result: "NaN", flags: "none" },
+
+  // Subtraction: positive result, negative result, signed-zero-equivalent, and invalid infinity subtraction.
+  { op: "sub", x: "4", y: "2", result: "2", flags: "none" },
+  { op: "sub", x: "2", y: "4", result: "-2", flags: "none" },
+  { op: "sub", x: "0", y: "0", result: "0", flags: "none" },
+  { op: "sub", x: "Infinity", y: "Infinity", result: "NaN", flags: "invalid" },
+
+  // Multiplication: positive, signed, zero, and invalid infinity-by-zero.
+  { op: "mul", x: "4", y: "2", result: "8", flags: "none" },
+  { op: "mul", x: "-2", y: "4", result: "-8", flags: "none" },
+  { op: "mul", x: "0", y: "5", result: "0", flags: "none" },
+  { op: "mul", x: "Infinity", y: "0", result: "NaN", flags: "invalid" },
+
+  // Division: normalized exact cases, fractional quotient, divide-by-zero, invalid zero-over-zero, and infinity quotient.
+  { op: "div", x: "4", y: "2", result: "2" },
+  { op: "div", x: "1", y: "1", result: "1" },
+  { op: "div", x: "1", y: "2", result: "0.5" },
+  { op: "div", x: "1", y: "0", result: "Infinity", flags: "div_by_zero" },
+  { op: "div", x: "0", y: "0", result: "NaN", flags: "invalid" },
+  { op: "div", x: "Infinity", y: "2", result: "Infinity", flags: "none" }
+];
+
+for (const testCase of cases) {
+  await assertOperation(testCase);
+}
+
+console.log("OK");

package/test-k-object.mjs

@@ -91,6 +91,25 @@ assert.match(decompiledSource, /\$ Nws3 =/);
 assert.match(decompiledSource, /^7jfi = /m);
 assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) 7jfi \$Nws3$/m);
 
+const natLibraryBuffer = compileLibraryBuffer(fs.readFileSync("Examples/nat.k", "utf8"), { source: "Examples/nat.k" });
+const natDecompiledSource = decompileObjectBuffer(natLibraryBuffer);
+const natRoundTripSource = decompileObjectBuffer(
+  compileLibraryBuffer(natDecompiledSource, { source: "Examples/nat.decompiled.k" })
+);
+const recursiveNatPattern = /\?\{<X0 succ, \.\.\.>=X0 x, <X1 succ, \.\.\.>=X1 y\} .* \?X1;/;
+assert.equal(natRoundTripSource, natDecompiledSource);
+assert.match(natDecompiledSource, recursiveNatPattern);
+
+const arithmeticsLibraryBuffer = compileLibraryBuffer(
+  fs.readFileSync("Examples/arithmetics.k", "utf8"),
+  { source: "Examples/arithmetics.k" }
+);
+const arithmeticsDecompiledSource = decompileObjectBuffer(arithmeticsLibraryBuffer);
+const arithmeticsRoundTripSource = decompileObjectBuffer(
+  compileLibraryBuffer(arithmeticsDecompiledSource, { source: "Examples/arithmetics.decompiled.k" })
+);
+assert.equal(arithmeticsRoundTripSource, arithmeticsDecompiledSource);
+
 assert.throws(() => k.compile("@A = (); @A"), /Parse error/);
 assert.throws(() => k.compile("$ @A = {}; $@A"), /Parse error/);
 assert.deepEqual(k.compile("7jfi = ?X0; 7jfi")(new Product({})).toJSON(), {});

package/test-repl.mjs

@@ -2,7 +2,7 @@ import assert from "node:assert";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
 import {
   aliasNames,
@@ -12,6 +12,7 @@ import {
   createState,
   evaluateInput,
   explicitSnippetTerminated,
+  helpText,
   isMainEntrypoint,
   lineHasExplicitContinuation,
   lineTerminatesSnippet
@@ -61,6 +62,8 @@ assert(completions.includes(`(${state.typeAliases.nat}`));
 
 completions = completeInput(":run su", state)[0];
 assert(completions.includes(":run succ"));
+completions = completeInput(":co", state)[0];
+assert(completions.includes(":codec"));
 
 completions = completeInput("$na", state)[0];
 assert(completions.includes("$nat"));
@@ -89,6 +92,7 @@ const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl-"));
 const libPath = path.join(tmpDir, "session.klib");
 const koPath = path.join(tmpDir, "succ.ko");
 const sourcePath = path.join(tmpDir, "session.k");
+const codecPath = path.join(tmpDir, "bool-codec.mjs");
 const symlinkPath = path.resolve(".test-k-repl-link");
 output = await evaluateInput(`:klib ${libPath}`, state);
 assert.equal(output[0], `saved ${libPath}`);
@@ -117,6 +121,61 @@ assert.match(output[0], /^twice = \$nat succ succ \$nat;  -- @/);
 output = await evaluateInput(":C nat", loadedSource);
 assert.match(output[0], /^\$ nat = < nat succ, @[^ ]+ zero >;  -- @/);
 
+const codecState = createState();
+output = await evaluateInput(":type bool = <{} true, {} false>", codecState);
+assert.match(output[0], /^\$ bool = @/);
+const boolHash = codecState.typeAliases.bool;
+const valueModuleUrl = pathToFileURL(path.resolve("Value.mjs")).href;
+fs.writeFileSync(codecPath, `
+import { Product, Variant } from ${JSON.stringify(valueModuleUrl)};
+
+export const name = "yn";
+export const codes = [${JSON.stringify(boolHash)}];
+
+export function parse(text) {
+  const tag = text.trim();
+  if (tag !== "true" && tag !== "false") throw new Error("expected true or false");
+  return new Variant(tag, new Product({}));
+}
+
+export function print(value) {
+  return value.tag;
+}
+`);
+assert.match(helpText(), /:codec load file/);
+output = await evaluateInput(":codec list", codecState);
+assert.equal(output[0], "(none)");
+completions = completeInput(":codec l", codecState)[0];
+assert(completions.includes(":codec load"));
+assert(completions.includes(":codec list"));
+completions = completeInput(`:codec load ${tmpDir}/bool`, codecState)[0];
+assert(completions.includes(`:codec load ${codecPath}`));
+output = await evaluateInput(`:codec load ${codecPath}`, codecState);
+assert.equal(output[0], `loaded codec yn for ${boolHash}`);
+output = await evaluateInput(":codec list", codecState);
+assert.match(output[0], new RegExp(`^yn ${boolHash.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}`));
+completions = completeInput(":input bo", codecState)[0];
+assert(completions.includes(":input bool"));
+completions = completeInput(":input bool y", codecState)[0];
+assert(completions.includes(":input bool yn"));
+output = await evaluateInput(":input bool yn", codecState);
+assert.equal(output[0], `input ${boolHash} using yn: enter value text`);
+output = await evaluateInput("true", codecState);
+assert.match(output[0], /\{\}\|true \?</);
+assert.match(output[0], /yn: true/);
+output = await evaluateInput("{} | false", codecState);
+assert.doesNotMatch(output[0], /yn: false/);
+
+const utf8State = createState();
+output = await evaluateInput(":load core.k", utf8State);
+assert.equal(output[0], "loaded core.k");
+output = await evaluateInput(":codec load ./codecs/utf8.mjs", utf8State);
+assert.equal(output[0], `loaded codec utf8 for ${utf8State.typeAliases.string}`);
+output = await evaluateInput(":input string utf8", utf8State);
+assert.equal(output[0], `input ${utf8State.typeAliases.string} using utf8: enter value text`);
+output = await evaluateInput("hello", utf8State);
+assert.match(output[0], /utf8: hello/);
+
 const replPath = fileURLToPath(new URL("./repl.mjs", import.meta.url));
 try {
   fs.rmSync(symlinkPath, { force: true });

package/tests.sh

@@ -11,5 +11,14 @@ node ./codecs/unit.mjs --parse | node ./codecs/unit.mjs --print | grep -qx '{}'
 echo 
 printf 'A🙂\nBé~\t' | ./codecs/utf8.mjs --parse | ./k.mjs -k Examples/byte.k |./codecs/utf8.mjs --print
 echo
-echo "1031" | ./codecs/ieee.mjs --parse | ./k.mjs -k Examples/ieee.k | ./codecs/ieee.mjs --print
+./objects/compile-lib.mjs Examples/ieee.k ieee.klib
+MUL=`./objects/extract-aliases.mjs ieee.klib | grep '^mul = @' | sed 's/^mul = \(@[^;]*\);.*$/\1/'`
+DIV=`./objects/extract-aliases.mjs ieee.klib | grep '^div = @' | sed 's/^div = \(@[^;]*\);.*$/\1/'`
+ARG=0.12
+printf "$ARG * $ARG = "
+echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib ieee.klib "{()x,()y} $MUL .result" | ./codecs/ieee.mjs --print
+printf "$ARG / $ARG = "
+DIV_RESULT=`echo $ARG | ./codecs/ieee.mjs --parse | ./k.mjs --lib ieee.klib "{()x,()y} $DIV .result" | ./codecs/ieee.mjs --print`
+echo "$DIV_RESULT"
+test "$DIV_RESULT" = "1"
 echo

package/type_registry/registry.mjs~

@@ -0,0 +1,105 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import codes from '../codes.mjs';
+import { parse } from './typeParser.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REGISTRY_FILE = path.join(__dirname, 'registry.json');
+const PORT = 3001;
+
+// Load existing registry if it exists
+if (fs.existsSync(REGISTRY_FILE)) {
+    console.log('Loading existing registry...');
+    try {
+        const data = fs.readFileSync(REGISTRY_FILE, 'utf8');
+        const json = JSON.parse(data);
+        codes.load(json);
+        console.log(`Loaded ${Object.keys(json).length} types.`);
+    } catch (err) {
+        console.error('Error loading registry:', err);
+    }
+} else {
+    console.log('No existing registry found. Starting fresh.');
+}
+
+const server = http.createServer((req, res) => {
+    // Helper to send JSON response
+    const sendJSON = (data, status = 200) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+
+    // Helper to send Error
+    const sendError = (message, status = 400) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: message }));
+    };
+
+    // Route: POST
+    if (req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            try {
+                // 1. Parse the input string using the Jison parser
+                // The parser expects a string of type definitions
+                console.log("Received body:", body);
+                const definitions = parse(body);
+                console.log("Parsed definitions:", JSON.stringify(definitions, null, 2));
+
+                // 2. Register the parsed codes
+                // codes.register returns the representatives map { temp_name: canonical_hash }
+                const representatives = codes.register(definitions);
+
+                // Filter out generated names (_gen_...) and canonical names (@...)
+                const filteredRepresentatives = Object.fromEntries(
+                    Object.entries(representatives).filter(([key, value]) => 
+                        !key.startsWith('_gen_') && !key.startsWith('@')
+                    )
+                );
+
+                // 3. Save to disk
+                const dump = codes.dump();
+                fs.writeFileSync(REGISTRY_FILE, JSON.stringify(dump, null, 2));
+
+                // 4. Return the mapping
+                sendJSON(filteredRepresentatives);
+
+            } catch (err) {
+                console.error(err);
+                sendError(`Registration failed: ${err.message}`);
+            }
+        });
+    }
+    // Route: GET 
+    else if (req.method === 'GET') {
+        const typeId = req.url.split('/').pop();
+        console.log("Requested type ID:", typeId);
+        if (!typeId) {
+            sendError('Missing type ID');
+            return;
+        }
+        // Decode URI component in case @ is encoded
+        const decodedId = decodeURIComponent(typeId);
+        console.log("Decoded type ID:", decodedId);
+        
+        const typeDef = codes.find(decodedId);
+        if (typeDef.code === 'undefined') {
+            sendError('Type not found', 404);
+        } else {
+            sendJSON(typeDef);
+        }
+    }
+    // 404 Not Found
+    else {
+        sendError('Not Found', 404);
+    }
+});
+
+server.listen(PORT, () => {
+    console.log(`Type Registry running at http://localhost:${PORT}/`);
+});

package/type_registry/typeParser.jison~

@@ -0,0 +1,132 @@
+%{
+
+let defs = {};
+let genCount = 0;
+let genNameId;
+
+function genName() {
+  return `_gen_${genCount++}`;
+}
+
+function fromEscString(escString) {
+  const isSingleQuoted = escString.startsWith("'");
+  let str = escString.substring(1, escString.length - 1);
+  if (isSingleQuoted) {
+    str = str.replace(/\\'/g, "'");
+  } else {
+    str = str.replace(/\\"/g, '"');
+  }
+  str = str.replace(/\\\\/g, '\\');
+  str = str.replace(/\\\//g, '/');
+  str = str.replace(/\\b/g, '\b');
+  str = str.replace(/\\f/g, '\f');
+  str = str.replace(/\\n/g, '\n');
+  str = str.replace(/\\r/g, '\r');
+  str = str.replace(/\\t/g, '\t');
+  str = str.replace(/\\u([\dA-F]{4})/gi, (match, p1) => String.fromCharCode(parseInt(p1, 16)));
+
+  return str;
+}
+
+%}
+
+%lex
+
+%%
+\s+                                            /* blanks */
+"<"                                            return 'LA';
+">"                                            return 'RA';
+"{"                                            return 'LC';
+"}"                                            return 'RC';
+"="                                            return 'EQ';
+","                                            return 'COMMA';
+";"                                            return 'SC';
+"@"                                            return 'AT';
+"$"                                            return 'DOLLAR';
+\"([^"\\]|\\(.|\n))*\"|\'([^'\\]|\\(.|\n))*\'  return 'STRING';
+[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*                return 'NAME';
+<<EOF>>                                        return 'EOF';
+.                                              return 'INVALID';
+
+/lex
+
+%token NAME STRING
+%token LA RA LC RC EQ COMMA SC AT DOLLAR
+%token EOF
+
+%start expressions
+
+%%
+
+expressions
+    : initialize_defs definitions EOF
+        { return defs; }
+    ;
+
+initialize_defs
+    : /* empty */
+        { defs = {}; genCount = 0; }
+    ;
+
+definitions
+    : definition
+    | definitions definition
+    ;
+
+definition
+    : DOLLAR name EQ LA field_list RA SC
+        { defs[$2] = { code: 'union', union: $5 }; }
+    | DOLLAR name EQ LC field_list RC SC
+        { defs[$2] = { code: 'product', product: $5 }; }
+    ;
+
+type_expr
+    : LA field_list RA
+        { 
+          genNameId = genName();
+          defs[genNameId] = { code: 'union', union: $2 }; 
+          $$ = genNameId;
+        }
+    | LC field_list RC
+        { 
+          genNameId = genName();
+          defs[genNameId] = { code: 'product', product: $2 }; 
+          $$ = genNameId;
+        }
+    | ref
+        { $$ = $1; }
+    ;
+
+ref
+    : name
+        { $$ = $1; }
+    | AT name
+        { $$ = '@' + $2; }
+    ;
+
+field_list
+    : /* empty */
+        { $$ = {}; }
+    | field
+        { $$ = {}; $$[$1.label] = $1.type; }
+    | field_list COMMA field
+        { $$ = $1; $$[$3.label] = $3.type; }
+    ;
+
+field
+    : type_expr label
+        { $$ = { type: $1, label: $2 }; }
+    ;
+
+label
+    : name
+        { $$ = $1; }
+    | str
+        { $$ = $1; }
+    ;
+
+name: NAME { $$ = yytext; };
+str: STRING { $$ = fromEscString(yytext); };
+
+%%
+

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
-  </state>
-</component>

package/.idea/copilot.data.migration.agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AskMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask2agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Ask2AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.edit.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EditMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/k.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/k.iml" filepath="$PROJECT_DIR$/.idea/k.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>