@fraczak/k 6.1.0 → 6.1.2

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-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
@@ -36,6 +37,13 @@ assert.match(output[0], /^succ = @/m);
 output = await evaluateInput(":run succ", state);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
+output = await evaluateInput("/zero", state);
+assert.equal(output[0], "... undefined");
+assert.equal(state.value.toJSON(), "succ");
+
+output = await evaluateInput("succ", state);
+assert.match(output[0], /^\{\}\|succ\|succ \?</);
+
 output = await evaluateInput(":t succ", state);
 assert.match(output[0], /^succ : /);
 
@@ -54,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"));
@@ -82,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}`);
@@ -97,7 +108,7 @@ const objectFn = objectToFunction(decodeObject(fs.readFileSync(koPath)));
 const objectResult = objectFn(new Product({}, [["closed-product", []]]));
 assert.equal(objectResult.toJSON(), "succ");
 
-fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = |succ;\n");
+fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = $nat |succ $nat;\ntwice = succ succ;\n");
 const loadedSource = createState();
 output = await evaluateInput(`:load ${sourcePath}`, loadedSource);
 assert.equal(output[0], `loaded ${sourcePath}`);
@@ -105,6 +116,65 @@ output = await evaluateInput(":codes", loadedSource);
 assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", loadedSource);
 assert.match(output[0], /^succ = @/m);
+output = await evaluateInput(":d twice", loadedSource);
+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 {

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