@fraczak/k 6.10.6 → 7.0.0

package/tests/code-derivation/dot.mjs

@@ -3,24 +3,18 @@ import { hash } from '../../hash.mjs';
 import assert from 'assert';
 
 t(`
-$b = < {} true, {} false > ; 
-$pair = { b one, b two } ;
-$bit = <{} 0, {} 1> ;
-1 = {} |1 $bit;
-$b {1 one, () two, () c} .one
+1 = {} |1 ?< {} 0, {} 1 >;
+?< {} true, {} false > {1 one, () two, () c} .one
 
 `, (annotated) => {
     const {input,output} = in_out(annotated);
-    // console.log({input,output});
-    assert.equal(input.type, annotated.representatives["b"]);
-    assert.equal(output.type, annotated.representatives["bit"]);
+    assert.equal(input.type, "@GWnxJCupZr96BZfdpDsfQQKxKjCbjyDh7Qaur7y9enCY");
+    assert.equal(output.type, "@MjusyRWZnVj8TR4BhFCCcMRrQbdKp9gPtC29LT9nZvjg");
     console.log("OK");
 });
 
 t(`
-    $bit = <{} 0, {} 1> ;
-    $a = < bit true, bit false > ;
-    $a /true
+    ?< <{} 0, {} 1> true, <{} 0, {} 1> false > /true
   `, (annotated) => {
   const {input,output} = in_out(annotated);
   console.log({input,output});

package/tests/code-derivation/nat.mjs

@@ -4,7 +4,7 @@ import assert from 'assert';
 
 t(fs.readFileSync("./Examples/nat.k", "utf8"), (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(output.type, annotated.representatives["nat"]);
-    assert.equal(input.type, annotated.representatives["nat"]);
+    assert.equal(output.type, input.type);
+    assert.equal(output.type, "@e9WP6QX6URfgnd9hHYrrYUBhiL7UcvbWErVmyQJfFcr8");
     console.log("OK");
 });

package/tests/code-derivation/not-not.mjs

@@ -1,14 +1,14 @@
 import { t, in_out } from './index.mjs';
 import assert from 'assert';
 
-t(`$b = < {} true, {} false > ;
-   true = {} |true $b;
-   false = {} |false $b; 
-   not = $b < /true false, /false true >;
+t(`
+   true = {} |true;
+   false = {} |false; 
+   not = ?< {} true, {} false > < /true false, /false true > ?< {} true, {} false >;
    not not
 `, (annotated) => {
    const {input,output} = in_out(annotated);
-   assert.equal(input.type, annotated.representatives["b"]);
-   assert.equal(output.type, annotated.representatives["b"]);
+   assert.equal(input.type, output.type);
+   assert.equal(input.type, "@GWnxJCupZr96BZfdpDsfQQKxKjCbjyDh7Qaur7y9enCY");
    console.log("OK");
    });

package/tests/code-derivation/pattern-envelope.mjs

@@ -12,9 +12,8 @@ const INT_PATTERN = [
 ];
 
 const script = `
-  $ bits = < {} _, bits 0, bits 1 >;
-  $ int = < bits +, bits - >;
-  {}|_|0|1|+ $int
+  int = ?< <bits 0, bits 1, {} _>=bits "+", bits "-" >;
+  {}|_|0|1|+ int
 `;
 
 const result = k.compile(script)(Value.product({}));
@@ -76,9 +75,8 @@ assert.throws(
 );
 
 const projectionScript = `
-  $ bits = < {} _, bits 0, bits 1 >;
-  $ int = < bits +, bits - >;
-  $int /+
+  int = ?< <bits 0, bits 1, {} _>=bits "+", bits "-" >;
+  int /+
 `;
 const annotated = k.annotate(projectionScript);
 run.defs = annotated;

package/tests/code-derivation/product.mjs

@@ -12,14 +12,11 @@ t('{}', (annotated) => {
 });
 
 t(`
-  $b = < {} true, {} false > ; 
-  $pair = { b one, b two } ;
-
-  {() one, () two} $pair
+  ?< {} true, {} false > {() one, () two} ?{ < {} true, {} false > one, < {} true, {} false > two }
 `, (annotated) => {
   const {input,output} = in_out(annotated);
 
-  assert.equal(input.type, annotated.representatives["b"]);
-  assert.equal(output.type, annotated.representatives["pair"]);
+  assert.equal(input.type, "@GWnxJCupZr96BZfdpDsfQQKxKjCbjyDh7Qaur7y9enCY");
+  assert.equal(output.type, "@ZR2yff4pdXTVqZdMu9x3t9GG5rwmhEfQuenbAwFnD2Nk");
   console.log("OK");
 });

package/tests/code-derivation/rlz.mjs

@@ -2,13 +2,12 @@ import { t, in_out } from './index.mjs';
 import assert from 'assert';
 
 t(`
- $nat = < {} _, nat 0, nat 1>;
- zero = {}|_|0 $nat;
- rlz =  </0/_ zero, /0 rlz, ()>;
+ zero = {}|_|0;
+ rlz = ?<X 0, X 1, {} _>=X </0/_ zero, /0 rlz, ()> ?X;
  rlz
  `, (annotated) => {
     const {input,output} = in_out(annotated);
-    assert.equal(output.type, annotated.representatives["nat"]);
-    assert.equal(input.type, annotated.representatives["nat"]);
+    assert.equal(output.type, input.type);
+    assert.equal(output.type, "@VtPHxGf5GNMzzyVFxtv7gegFfJRYapBGtCeyV56bs5Zb");
     console.log("OK");
  });

package/tests/test-codecs.mjs

@@ -171,7 +171,7 @@ console.log("6. Verifying pattern derivation via k type system (patternFromFilte
   assert.deepEqual(UnitCodec.UNIT_PATTERN, unitPat);
 
   const listPat = SDK.patternFromFilter(
-    '$ bits = < bits 0, bits 1, {} _ >; $ int = < bits "+", bits "-" >; ?< {} nil, { $int car, list cdr } cons > = list'
+    '?< {} nil, { < <bits 0, bits 1, {} _>=bits "+", bits "-" > car, list cdr } cons > = list'
   );
   assert.deepEqual(IntCodec.INT_LIST_PATTERN, listPat);
 

package/tests/test-fingerprint.mjs

@@ -1,43 +1,38 @@
-import k from '../index.mjs';
-import { encodeCodeToString, find } from '../codes.mjs';
+import codes, { encodeCodeToString } from '../codes.mjs';
 import hash from '../hash.mjs';
-[
-    `
-    $bits = < bits 0,  bits 1, {} _ >;
-    $nat = < {} zero, nat succ>;
-    $pair = {nat x, nat y};
-    $b = { bits"x", bits y};
-    $tree = < {nat value, tree left, tree right} binary, nat leaf, {nat value, tree tree} unary >;
-  
-    succ =  | succ $nat;
-    plus = $pair <
-      {.x/zero stop, .y result} .result,
-      {.x/succ x, .y succ y } plus
-    > $nat;
-  {}|zero succ succ {() x, () y} plus
-    `     
-  ].map(function (script) {
-    console.log("test-fingerprint:");
-    // console.log(`k_expression = '${script}';`);
-    const annotated = k.annotate(script);
-    // console.log(annotated);
-    let ERRORS = 0;
-    for (const code in annotated.representatives) {
-      // console.log(`CODE: ${code}`);
-      const s = encodeCodeToString(annotated.representatives[code]);
-      // console.log(` - DEFS: ${s}`);;
-      const annotated2 = k.annotate(s+" {}");;
-      const s2 = encodeCodeToString(annotated2.representatives["C0"]);
-      // console.log(` - reparsed FINGERPRINT: ${hash(s2)}`);
-      if (!((s === s2) && (hash(s) === hash(s2)))) {
-        ERRORS++;
-        console.log(` ERROR - reparsed FINGERPRINT for ${code} is different`);
-      } 
-    }
-    if (ERRORS === 0) {
-      console.log("OK");
-    } else {
-      console.log(" ----- ERRORS");
-    }
-  });
+import assert from 'assert';
+
+console.log("test-fingerprint:");
+const codeDefs = {
+  bits: { code: "union", union: { "0": "bits", "1": "bits", "_": "{}" } },
+  nat: { code: "union", union: { zero: "{}", succ: "nat" } },
+  pair: { code: "product", product: { x: "nat", y: "nat" } },
+  b: { code: "product", product: { x: "bits", y: "bits" } },
+  tree: { code: "union", union: {
+    binary: "binNode",
+    leaf: "nat",
+    unary: "unNode"
+  } },
+  binNode: { code: "product", product: { value: "nat", left: "tree", right: "tree" } },
+  unNode: { code: "product", product: { value: "nat", tree: "tree" } },
+  "{}": { code: "product", product: {} }
+};
+
+const reps = codes.register(codeDefs);
+let errors = 0;
+for (const code in reps) {
+  const rep = reps[code];
+  const s = encodeCodeToString(rep);
+  const h = hash(s);
+  if (rep !== h) {
+    errors++;
+    console.log(` ERROR - fingerprint mismatch for ${code}: ${rep} !== ${h}`);
+  }
+}
+
+if (errors === 0) {
+  console.log("OK");
+} else {
+  console.log(" ----- ERRORS");
+}
   

package/tests/test-hash-normalization.mjs

@@ -67,16 +67,14 @@ f
 // SCC order should not change hash
 {
   const scriptA = `
-$bit = < {} 0, {} 1 >;
-f = $bit < /0 |0 g, /1 >;
-g = $bit < /0 |0 f, /1 >;
+f = ?< {} 0, {} 1 > < /0 |0 g, /1 >;
+g = ?< {} 0, {} 1 > < /0 |0 f, /1 >;
 f
   `;
 
   const scriptB = `
-$bit = < {} 0, {} 1 >;
-g = $bit < /0 |0 f, /1 >;
-f = $bit < /0 |0 g, /1 >;
+g = ?< {} 0, {} 1 > < /0 |0 f, /1 >;
+f = ?< {} 0, {} 1 > < /0 |0 g, /1 >;
 f
   `;
 

package/tests/test-ieee-arithmetic.mjs

@@ -6,25 +6,25 @@ import codes from "../codes.mjs";
 import { parse as parseFloat64, print as printFloat64 } from "../codecs/ieee.mjs";
 import { closedPatternToCodeHash, valueForCode } from "../repl-codecs.mjs";
 
-const state = createState();
+const state = createState({ engine: "js" });
 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;
+const sampleFloat = parseFloat64("0");
+const float64Hash = closedPatternToCodeHash(sampleFloat.pattern);
 
 function float64(text) {
-  return valueForCode(parseFloat64(text), float64Hash, codes.find);
+  return parseFloat64(text);
 }
 
 function floatPair(x, y) {
-  return valueForCode(Value.product({
+  return Value.product({
     x: float64(x),
     y: float64(y)
-  }), floatPairHash, codes.find);
+  });
 }
 
 async function runOperation(op, x, y) {
@@ -40,7 +40,6 @@ async function runProjectedResult(op, x, y) {
 }
 
 function assertFloatResult(value, expected, label) {
-  assert.equal(closedPatternToCodeHash(value.pattern), float64Hash, `${label}: result should keep float64 envelope`);
   assert.equal(printFloat64(value), expected, label);
 }
 

package/tests/test-k-object.mjs

@@ -51,9 +51,7 @@ const INT_PATTERN = [
 ];
 
 const objectBuffer = compileObjectBuffer(`
-  $ bits = < {} _, bits 0, bits 1 >;
-  $ int = < bits +, bits - >;
-  {}|_|0|1|+ $int
+  {}|_|0|1|+ ?< <bits 0, bits 1, {} _>=bits "+", bits "-">
 `);
 assert.equal(objectBuffer.subarray(0, 5).toString("utf8"), "KOBJ\n");
 const object = decodeObject(objectBuffer);
@@ -84,19 +82,17 @@ const decompiledSource = decompileObjectBuffer(objectBuffer);
 const decompiledResult = k.compile(decompiledSource)(Value.product({}));
 assert.deepEqual(decompiledResult.pattern, INT_PATTERN);
 assert.deepEqual(decompiledResult.toJSON(), objectResult.toJSON());
-assert.match(decompiledSource, /^----- codes -----$/m);
 assert.match(decompiledSource, /^----- rels -----$/m);
 assert.match(decompiledSource, /^----- main -----$/m);
-assert.match(decompiledSource, /\$ Nws3 =/);
-assert.match(decompiledSource, /^7jfi = /m);
-assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) 7jfi \$Nws3$/m);
+assert.match(decompiledSource, /^[A-Za-z0-9_]+ = /m);
+assert.match(decompiledSource, /^----- main -----\n\?\(\.\.\.\) [A-Za-z0-9_]+ \?<<X0 0, X0 1, {} _>=X0 \+, X0 ->$/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 = /\$dTww <\{\.x PgmQ x, \.y h4Wg y\} re64, \.y> \$e9WP;/;
+const recursiveNatPattern = /\?\{<\{\} 0, X0 \+1>=X0 x, <X1 \+1, \.\.\.>=X1 y\} <\{\.x [A-Za-z0-9_]+ x, \.y [A-Za-z0-9_]+ y\} [A-Za-z0-9_]+, \.y> \?X1;/;
 assert.equal(natRoundTripSource, natDecompiledSource);
 assert.match(natDecompiledSource, recursiveNatPattern);
 
@@ -111,14 +107,14 @@ const arithmeticsRoundTripSource = decompileObjectBuffer(
 assert.equal(arithmeticsRoundTripSource, arithmeticsDecompiledSource);
 
 assert.throws(() => k.compile("@A = (); @A"), /Parse error/);
-assert.throws(() => k.compile("$ @A = {}; $@A"), /Parse error/);
+assert.throws(() => k.compile("$ @A = {}; $@A"), /Lexical error/);
 assert.deepEqual(k.compile("7jfi = ?X0; 7jfi")(Value.product({})).toJSON(), {});
 
 const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a = b |y; a"));
-assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
+assert.match(sccSource, /----- rels -----\n[A-Za-z0-9_]+ = .+\n\n[A-Za-z0-9_]+ = .+\n\n[A-Za-z0-9_]+ = /s);
 assert.deepEqual(k.compile(sccSource)(Value.product({})).toJSON(), { y: "x" });
 
-const libraryBuffer = compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" });
+const libraryBuffer = compileLibraryBuffer("zero = {}|zero;\nsucc = |succ;\n", { source: "defs-only.k" });
 assert.equal(libraryBuffer.subarray(0, 1).toString("utf8"), "{");
 const library = decodeObject(libraryBuffer);
 assert.equal("version" in library, false);
@@ -133,10 +129,10 @@ assert(Object.values(library.rels).every((rel) =>
 ));
 assert(Object.values(library.rels).every((rel) => rel.def.op !== "comp" || rel.def.comp[0]?.op !== "filter"));
 assert(Object.values(library.meta).some(({ type, origins }) =>
-  type === "code" &&
+  type === "rel" &&
   origins.some((origin) =>
     origin.source === "defs-only.k" &&
-    origin.name === "nat" &&
+    origin.name === "zero" &&
     typeof origin.compiledAt === "string" &&
     origin.start &&
     origin.end
@@ -158,11 +154,11 @@ const derivedLibrary = decodeObject(compileLibraryBuffer("other = |other;\n", {
   libraries: [library]
 }));
 const derivedAliases = extractAliasesFromObject(derivedLibrary);
-assert.match(derivedAliases, /^\$ nat = @/m);
+assert.match(derivedAliases, /^zero = @/m);
 assert.match(derivedAliases, /^succ = @/m);
 assert.match(derivedAliases, /^other = @/m);
-assert(derivedAliases.indexOf("$ nat = @") < derivedAliases.indexOf("other = @"));
 assert(derivedAliases.indexOf("other = @") < derivedAliases.indexOf("succ = @"));
+assert(derivedAliases.indexOf("succ = @") < derivedAliases.indexOf("zero = @"));
 
 {
   const warn = console.warn;

package/tests/test-kir.mjs

@@ -9,7 +9,6 @@ import {
 import { validateKIRP } from "../objects/validate.mjs";
 
 const object = decodeObject(compileObjectBuffer(`
-  $ bit = < {} 0, {} 1 >;
   id = ();
   .x id
 `, { source: "kir-test.k" }));

package/tests/test-kvm-polymorphic.mjs

@@ -91,8 +91,7 @@ console.log("==> Starting Polymorphic kVM & Specialization Tests");
 // Test 3: Type Error on Envelope Mismatch
 {
   const script = `
-    $ bool = < {} true, {} false >;
-    check = $bool;
+    check = ?< {} true, {} false >;
     check
   `;
   const obj = decodeObject(compileObjectBuffer(script));

package/tests/test-kvm.mjs

@@ -84,8 +84,7 @@ console.log("==> Starting kVM Tests");
 // Test 7: Filters & Types
 {
   const script = `
-    $ bool = < {} true, {} false >;
-    $ bool
+    ?< {} true, {} false >
   `;
   const result1 = runKVM(script, { true: {} });
   assert.deepEqual(toJSON(result1), "true");
@@ -98,9 +97,8 @@ console.log("==> Starting kVM Tests");
 // Test 8: Recursive List traversal (Cons/Nil)
 {
   const script = `
-    $ bool = < {} true, {} false >;
-    true = {} | true $bool;
-    false = {} | false $bool;
+    true = {} | true;
+    false = {} | false;
     
     list? = ?< {} nil, {X car, Y cdr} cons > = Y;
     nil = {}|nil list?;
@@ -130,12 +128,11 @@ console.log("==> Starting kVM Tests");
 // Test 9: Comparing KVM execution vs Native JS run (Envelope-aware and Envelope-free)
 {
   const script = `
-    $ nat = < {} 0, nat +1 >;
-    0 = {} | 0 $ nat;
-    inc = | +1 $ nat;
-    dec = $ nat / +1;
-    add = $ { nat x, nat y } <
-      { . x dec x, . y inc y } add,
+    0 = {} | 0;
+    inc = | +1;
+    dec = / +1;
+    add = ?{ < {} 0, N +1 > = N x, ... } = X <
+      { . x dec x, . y inc y } ?X add,
       . y
     >;
   `;

package/tests/test-repl-html.mjs

@@ -581,6 +581,7 @@ if (chromiumBin) {
       const hasTime = modalText.includes(":time");
       const hasT = modalText.includes(":t <name>");
       const hasCodecDefine = modalText.includes(":codec define");
+      const hasRels = modalText.includes(":rels");
       const hasType = modalText.includes(":type <name>");
       const hasTypes = modalText.includes(":types");
       const hasCodes = modalText.includes(":codes");
@@ -592,6 +593,7 @@ if (chromiumBin) {
         rect: { left: rect.left, right: rect.right, top: rect.top, bottom: rect.bottom },
         helpModalOpen,
         hasRel,
+        hasRels,
         hasVal,
         hasTiming,
         hasTime,
@@ -608,8 +610,9 @@ if (chromiumBin) {
     assert.strictEqual(narrowNavbarCheck.isVisible, true, "#btn-help should be visible within narrow viewport");
     assert.strictEqual(narrowNavbarCheck.helpModalOpen, true, "Clicking #btn-help in narrow viewport should open help modal");
     assert.strictEqual(narrowNavbarCheck.hasRel, true, "Help modal should contain :rel <name>");
-    assert.strictEqual(narrowNavbarCheck.hasType, true, "Help modal should contain :type <name>");
-    assert.strictEqual(narrowNavbarCheck.hasTypes, true, "Help modal should contain :types");
+    assert.strictEqual(narrowNavbarCheck.hasRels, true, "Help modal should contain :rels");
+    assert.strictEqual(narrowNavbarCheck.hasType, false, "Help modal should not contain :type <name>");
+    assert.strictEqual(narrowNavbarCheck.hasTypes, false, "Help modal should not contain :types");
     assert.strictEqual(narrowNavbarCheck.hasEngine, true, "Help modal should contain :engine");
     assert.strictEqual(narrowNavbarCheck.hasCodes, false, "Help modal should not contain :codes");
     assert.strictEqual(narrowNavbarCheck.hasTime, false, "Help modal should not contain :time");