@fraczak/k 6.2.3 → 6.3.1

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

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import k from "../../index.mjs";
-import { Product, Variant, mergePatterns, withPattern } from "../../Value.mjs";
+import { Value, mergePatterns, withPattern } from "../../Value.mjs";
 import { decodeWire, encodeToWire } from "../../codecs/runtime/prefix-codec.mjs";
 import run from "../../run.mjs";
 import codes from "../../codes.mjs";
@@ -17,16 +17,16 @@ const script = `
   {}|_|0|1|+ $int
 `;
 
-const result = k.compile(script)(new Product({}));
+const result = k.compile(script)(Value.product({}));
 assert.deepEqual(result.pattern, INT_PATTERN);
 
 const decoded = decodeWire(encodeToWire(result, result.pattern));
 assert.deepEqual(decoded.pattern, INT_PATTERN);
 
-const two = new Variant("+",
-  new Variant("1",
-    new Variant("0",
-      new Variant("_", new Product({}))
+const two = Value.variant("+",
+  Value.variant("1",
+    Value.variant("0",
+      Value.variant("_", Value.product({}))
     )
   )
 );
@@ -53,13 +53,13 @@ const wrappedFloatPattern = [
   ["closed-product", []],
   ["closed-union", [["inexact", 5]]]
 ];
-const wrappedFloat = new Product({
-  result: new Product({
-    sign: new Variant("+", new Product({})),
-    exponent: new Product({ 0: new Variant("1", new Product({})) }),
-    fraction: new Product({ 0: new Variant("0", new Product({})) })
+const wrappedFloat = Value.product({
+  result: Value.product({
+    sign: Value.variant("+", Value.product({})),
+    exponent: Value.product({ 0: Value.variant("1", Value.product({})) }),
+    fraction: Value.product({ 0: Value.variant("0", Value.product({})) })
   }),
-  flags: new Variant("inexact", new Product({}))
+  flags: Value.variant("inexact", Value.product({}))
 });
 const resultProjection = k.compile(".result")(withPattern(wrappedFloat, wrappedFloatPattern));
 assert.deepEqual(resultProjection.pattern, [

package/tests/integration.sh

@@ -19,6 +19,22 @@ grep -q '"__main__"' "$TMP_DIR/stdin.kvm"
 ./objects/compile.mjs --lib "$TMP_DIR/export.klib" --export id:alias 'alias' "$TMP_DIR/export.ko"
 ./objects/decompile.mjs "$TMP_DIR/export.ko" | grep -q '^----- main -----$'
 node ./codecs/unit.mjs --parse | ./k.mjs --lib "$TMP_DIR/export.klib" --export id:alias 'alias' | node ./codecs/unit.mjs --print | grep -qx '{}'
+node ./codecs/unit.mjs --parse | ./k.mjs "$TMP_DIR/export.ko" | node ./codecs/unit.mjs --print | grep -qx '{}'
+if ./k.mjs --lib "$TMP_DIR/export.klib" --lib "$TMP_DIR/export.klib" '()' > "$TMP_DIR/two-lib.out" 2> "$TMP_DIR/two-lib.err"; then
+  echo "expected repeated --lib to fail" >&2
+  exit 1
+fi
+grep -q -- '--lib may be specified at most once' "$TMP_DIR/two-lib.err"
+if ./objects/compile.mjs --lib "$TMP_DIR/export.klib" --lib "$TMP_DIR/export.klib" '()' "$TMP_DIR/two-lib.ko" > "$TMP_DIR/two-lib-compile.out" 2> "$TMP_DIR/two-lib-compile.err"; then
+  echo "expected repeated k-compile --lib to fail" >&2
+  exit 1
+fi
+grep -q -- '--lib may be specified at most once' "$TMP_DIR/two-lib-compile.err"
+if ./kvm.mjs --lib "$TMP_DIR/export.klib" --lib "$TMP_DIR/export.klib" '()' > "$TMP_DIR/two-lib-kvm.out" 2> "$TMP_DIR/two-lib-kvm.err"; then
+  echo "expected repeated k-vm --lib to fail" >&2
+  exit 1
+fi
+grep -q -- '--lib may be specified at most once' "$TMP_DIR/two-lib-kvm.err"
 if ./objects/compile.mjs "$TMP_DIR/missing.k" > "$TMP_DIR/missing.out" 2> "$TMP_DIR/missing.err"; then
   echo "expected missing .k input to fail" >&2
   exit 1
@@ -27,11 +43,20 @@ grep -q 'Input file not found:' "$TMP_DIR/missing.err"
 
 echo '["zebara", "ela", "kupa", ala, owca]' | node ./codecs/k-parse.mjs | ./k.mjs '{.1 0,.3 1}' | node ./codecs/k-print.mjs
 echo 
+echo "a" | ./codecs/k-parse.mjs --input-type '?< {} a, X b, ...>' | ./k.mjs '{() i, /a o}' | ./codecs/show.mjs > "$TMP_DIR/polymorphic-relation.wire" 2> "$TMP_DIR/polymorphic-relation.show"
+grep -Fqx '{{}|a i, {} o} ?{<{}=X0 a, (...) b, ...> i, X0 o}' "$TMP_DIR/polymorphic-relation.show"
+./codecs/k-print.mjs "$TMP_DIR/polymorphic-relation.wire" | grep -qx '{"i":"a","o":{}}'
+echo
 echo '-21' | node ./codecs/int.mjs --parse | node ./codecs/int.mjs --print | grep -qx -- '-21'
 echo
 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
+if ./k.mjs -k Examples/byte.k > "$TMP_DIR/dash-k.out" 2> "$TMP_DIR/dash-k.err"; then
+  echo "expected -k to fail" >&2
+  exit 1
+fi
+grep -q -- '-k is no longer supported' "$TMP_DIR/dash-k.err"
+printf 'A🙂\nBé~\t' | ./codecs/utf8.mjs --parse | ./k.mjs Examples/byte.k |./codecs/utf8.mjs --print
 echo
 ./objects/compile.mjs Examples/ieee.k "$TMP_DIR/ieee.klib"
 MUL=`./objects/extract-aliases.mjs "$TMP_DIR/ieee.klib" | grep '^mul = @' | sed 's/^mul = \(@[^;]*\);.*$/\1/'`

package/tests/test-deep-wire-value.mjs

@@ -1,5 +1,5 @@
 import assert from "node:assert/strict";
-import { Product, Variant } from "../Value.mjs";
+import { Value } from "../Value.mjs";
 import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
 
 const depth = 12000;
@@ -9,12 +9,12 @@ const pattern = [
   ["closed-product", []]
 ];
 
-let bits = new Variant("_", new Product({}));
+let bits = Value.variant("_", Value.product({}));
 for (let i = 0; i < depth; i++) {
-  bits = new Variant("1", bits);
+  bits = Value.variant("1", bits);
 }
 
-const wire = encodeToWire(new Variant("+", bits), pattern);
+const wire = encodeToWire(Value.variant("+", bits), pattern);
 const decoded = decodeWire(wire).value;
 assert.equal(decoded.tag, "+");
 

package/tests/test-ieee-arithmetic.mjs

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 
 import { createState, evaluateInput } from "../repl.mjs";
-import { Product } from "../Value.mjs";
+import { Value, isProduct } 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";
@@ -21,7 +21,7 @@ function float64(text) {
 }
 
 function floatPair(x, y) {
-  return valueForCode(new Product({
+  return valueForCode(Value.product({
     x: float64(x),
     y: float64(y)
   }), floatPairHash, codes.find);
@@ -46,7 +46,7 @@ function assertFloatResult(value, expected, label) {
 
 async function assertOperation({ op, x, y, result, flags = null, projection = false }) {
   const bundle = await runOperation(op, x, y);
-  assert.ok(bundle instanceof Product, `${op} should return a result bundle`);
+  assert.ok(isProduct(bundle), `${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) {

package/tests/test-k-object.mjs

@@ -3,7 +3,7 @@ import fs from "node:fs";
 import k from "../index.mjs";
 import { parseValue } from "../valueIO.mjs";
 import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "../codecs/runtime/prefix-codec.mjs";
-import { Product, Variant } from "../Value.mjs";
+import { Value } from "../Value.mjs";
 import { exportPatternGraph } from "../codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "../codecs/runtime/pattern-json.mjs";
 import {
@@ -27,9 +27,9 @@ assert.deepEqual(decodedWire.pattern, [
 ]);
 assert.deepEqual(decodedWire.value.toJSON(), value.toJSON());
 
-const unicodeLabelValue = new Product({
-  "é": new Variant("🙂", new Product({})),
-  "𐐷": new Product({})
+const unicodeLabelValue = Value.product({
+  "é": Value.variant("🙂", Value.product({})),
+  "𐐷": Value.product({})
 });
 const unicodeWire = encodeToWire(unicodeLabelValue, null);
 const decodedUnicode = decodeWire(unicodeWire);
@@ -73,15 +73,15 @@ assert(object.meta[object.relAlias.__main__]?.origins?.some((origin) =>
 ));
 
 const objectFn = objectToFunction(object);
-const objectResult = objectFn(new Product({}));
+const objectResult = objectFn(Value.product({}));
 assert.deepEqual(objectResult.pattern, INT_PATTERN);
 assert.deepEqual(objectResult.toJSON(), { "+": { "1": { "0": "_" } } });
-const convergedObjectResult = runConvergedObject(object, new Product({}));
+const convergedObjectResult = runConvergedObject(object, Value.product({}));
 assert.deepEqual(convergedObjectResult.pattern, INT_PATTERN);
 assert.deepEqual(convergedObjectResult.toJSON(), objectResult.toJSON());
 
 const decompiledSource = decompileObjectBuffer(objectBuffer);
-const decompiledResult = k.compile(decompiledSource)(new Product({}));
+const decompiledResult = k.compile(decompiledSource)(Value.product({}));
 assert.deepEqual(decompiledResult.pattern, INT_PATTERN);
 assert.deepEqual(decompiledResult.toJSON(), objectResult.toJSON());
 assert.match(decompiledSource, /^----- codes -----$/m);
@@ -112,11 +112,11 @@ 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(), {});
+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.deepEqual(k.compile(sccSource)(new Product({})).toJSON(), { y: "x" });
+assert.deepEqual(k.compile(sccSource)(Value.product({})).toJSON(), { y: "x" });
 
 const libraryBuffer = compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" });
 assert.equal(libraryBuffer.subarray(0, 1).toString("utf8"), "{");
@@ -173,7 +173,7 @@ assert(derivedAliases.indexOf("other = @") < derivedAliases.indexOf("succ = @"))
     }));
     assert.equal(nonConverged.rels.__main__.typeDerivation.status, "not-converged");
     assert.throws(
-      () => runConvergedObject(nonConverged, new Product({ x: new Product({}) })),
+      () => runConvergedObject(nonConverged, Value.product({ x: Value.product({}) })),
       /type derivation is not-converged/
     );
   } finally {

package/tests/test-kvm.mjs

@@ -2,7 +2,7 @@ import assert from "node:assert";
 import k from "../index.mjs";
 import { lowerToKVM, executeKVM } from "../kvm.mjs";
 import codes from "../codes.mjs";
-import { fromObject, Product, Variant } from "../Value.mjs";
+import { fromObject } from "../Value.mjs";
 import run, { run_converged } from "../run.mjs";
 
 function runKVM(script, data, options = {}) {

package/tests/test-repl.mjs

@@ -18,7 +18,7 @@ import {
   lineTerminatesSnippet
 } from "../repl.mjs";
 import { decodeObject, objectToFunction } from "../object.mjs";
-import { Product } from "../Value.mjs";
+import { Value } from "../Value.mjs";
 
 const state = createState();
 
@@ -123,7 +123,7 @@ assert(completions.includes(`:load --no-alias ${libPath}`));
 output = await evaluateInput(`:ko ${koPath} succ`, state);
 assert.equal(output[0], `saved ${koPath} (succ)`);
 const objectFn = objectToFunction(decodeObject(fs.readFileSync(koPath)));
-const objectResult = objectFn(new Product({}, [["closed-product", []]]));
+const objectResult = objectFn(Value.product({}, [["closed-product", []]]));
 assert.equal(objectResult.toJSON(), "succ");
 
 fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = $nat |succ $nat;\ntwice = succ succ;\n");
@@ -145,7 +145,7 @@ 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)};
+import { Value } from ${JSON.stringify(valueModuleUrl)};
 
 export const name = "yn";
 export const codes = [${JSON.stringify(boolHash)}];
@@ -153,7 +153,7 @@ 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({}));
+  return Value.variant(tag, Value.product({}));
 }
 
 export function print(value) {

package/tests/test-structural-values.mjs

@@ -0,0 +1,27 @@
+import assert from "node:assert/strict";
+
+import { Value, isProduct, isVariant, isValue } from "../Value.mjs";
+import { INT_PATTERN, print as printInt } from "../codecs/int.mjs";
+import { print as printUnit } from "../codecs/unit.mjs";
+import { valueToK } from "../codecs/runtime/show-value.mjs";
+import { decodeWire, encodeToWire } from "../codecs/runtime/prefix-codec.mjs";
+
+const foreign = await import("../Value.mjs?structural-values-regression");
+
+assert.notEqual(foreign.Value, Value);
+
+const foreignUnit = foreign.Value.product({});
+const foreignTwo = foreign.Value.variant("+",
+  foreign.Value.variant("1",
+    foreign.Value.variant("0",
+      foreign.Value.variant("_", foreignUnit))));
+
+assert.equal(isProduct(foreignUnit), true);
+assert.equal(isVariant(foreignTwo), true);
+assert.equal(isValue(foreignTwo), true);
+assert.equal(printUnit(foreignUnit), "{}");
+assert.equal(printInt(foreignTwo), "2");
+assert.equal(valueToK(foreignTwo), "{}|_|0|1|+");
+
+const decoded = decodeWire(encodeToWire(foreignTwo, INT_PATTERN)).value;
+assert.equal(printInt(decoded), "2");

package/valueIO.mjs

@@ -9,7 +9,7 @@
  */
 
 import { parse as parseValueText } from "./valueParser.mjs";
-import { Value, fromObject } from "./Value.mjs";
+import { fromObject } from "./Value.mjs";
 
 /**
  * Parse a value from text with optional type information

package/valueParser.jison

@@ -1,6 +1,6 @@
 %{
 
-import { Product, Variant } from "./Value.mjs";
+import { Value } from "./Value.mjs";
 
 //--------------------------
 
@@ -87,19 +87,19 @@ input_with_eof
 exp
     : lc labelled rc                    { $$ = {value: $2.value, start: $1.start, end: $3.end}; }
     | lb exps rb                        { $$ = {value: $2.value, start: $1.start, end: $3.end}; }
-    | str            { $$ = {value: new Variant($1.value, new Product({})), start: $1.start, end: $1.end}; }
-    | name           { $$ = {value: new Variant($1.value, new Product({})), start: $1.start, end: $1.end}; }
+    | str            { $$ = {value: Value.variant($1.value, Value.product({})), start: $1.start, end: $1.end}; }
+    | name           { $$ = {value: Value.variant($1.value, Value.product({})), start: $1.start, end: $1.end}; }
     ;
 
 exps
-    : /* empty */                       { $$ = {value: new Product({})}; }
+    : /* empty */                       { $$ = {value: Value.product({})}; }
     | non_empty_exps                    {
                                           if ($1.list.length === 1) {
-                                            $$ = {value: new Variant('0', $1.list[0].value)};
+                                            $$ = {value: Value.variant('0', $1.list[0].value)};
                                           } else {
                                             const product = {};
                                             $1.list.forEach( (e, i) => product[i] = e.value );
-                                            $$ = {value: new Product(product)};
+                                            $$ = {value: Value.product(product)};
                                           };
                                         }
     ;
@@ -111,10 +111,10 @@ non_empty_exps
     ;
 
 labelled
-    : /* empty */                       { $$ = {value: new Product({})}; }
+    : /* empty */                       { $$ = {value: Value.product({})}; }
     | non_empty_labelled                {
                                           if ($1.list.length === 1) {
-                                            $$ = {value: new Variant($1.list[0].label, $1.list[0].value)};
+                                            $$ = {value: Value.variant($1.list[0].label, $1.list[0].value)};
                                           } else {
                                             const product = {};
                                             for (const {label, value} of $1.list) {
@@ -122,7 +122,7 @@ labelled
                                                 anError(@0,`Duplicate label '${label}'.`);
                                               product[label] = value;
                                             }
-                                            $$ = {value: new Product(product)};
+                                            $$ = {value: Value.product(product)};
                                           };
                                         }
     ;

package/valueParser.mjs

@@ -75,7 +75,7 @@
 
 
 
-import { Product, Variant } from "./Value.mjs";
+import { Value } from "./Value.mjs";
 
 //--------------------------
 
@@ -144,19 +144,19 @@ case 10: case 11:
  this.$ = {value: $$[$0-1].value, start: $$[$0-2].start, end: $$[$0].end}; 
 break;
 case 12: case 13:
- this.$ = {value: new Variant($$[$0].value, new Product({})), start: $$[$0].start, end: $$[$0].end}; 
+ this.$ = {value: Value.variant($$[$0].value, Value.product({})), start: $$[$0].start, end: $$[$0].end}; 
 break;
 case 14: case 18:
- this.$ = {value: new Product({})}; 
+ this.$ = {value: Value.product({})}; 
 break;
 case 15:
 
                                           if ($$[$0].list.length === 1) {
-                                            this.$ = {value: new Variant('0', $$[$0].list[0].value)};
+                                            this.$ = {value: Value.variant('0', $$[$0].list[0].value)};
                                           } else {
                                             const product = {};
                                             $$[$0].list.forEach( (e, i) => product[i] = e.value );
-                                            this.$ = {value: new Product(product)};
+                                            this.$ = {value: Value.product(product)};
                                           };
                                         
 break;
@@ -169,7 +169,7 @@ break;
 case 19:
 
                                           if ($$[$0].list.length === 1) {
-                                            this.$ = {value: new Variant($$[$0].list[0].label, $$[$0].list[0].value)};
+                                            this.$ = {value: Value.variant($$[$0].list[0].label, $$[$0].list[0].value)};
                                           } else {
                                             const product = {};
                                             for (const {label, value} of $$[$0].list) {
@@ -177,7 +177,7 @@ case 19:
                                                 anError(this._$,`Duplicate label '${label}'.`);
                                               product[label] = value;
                                             }
-                                            this.$ = {value: new Product(product)};
+                                            this.$ = {value: Value.product(product)};
                                           };
                                         
 break;