@fraczak/k 6.2.4 → 6.3.1

package/codecs/runtime/test-codec.mjs

@@ -6,7 +6,7 @@
 import { deriveClosedPattern } from './codec.mjs';
 import { encodeToWire, decodeWire } from './prefix-codec.mjs';
 import { patternToPropertyList } from './pattern-json.mjs';
-import { Product, Variant } from '../../Value.mjs';
+import { Value, isProduct, isVariant } from '../../Value.mjs';
 import hash from '../../hash.mjs';
 
 // Type repository
@@ -44,7 +44,7 @@ function resolveType(typeName) {
 
 // Test 1: Unit value
 console.log('\n=== Test 1: Unit ===');
-const unitValue = new Product({});
+const unitValue = Value.product({});
 console.log('Encoding unit:', unitValue.toString());
 
 const unitPattern = patternToPropertyList(deriveClosedPattern(unitTypeName, unitTypeDef, resolveType));
@@ -54,12 +54,12 @@ console.log('Hex:', unitEncoded.toString('hex'));
 
 const unitDecoded = decodeWire(unitEncoded);
 console.log('Decoded value:', unitDecoded.value.toString());
-console.log('Match:', unitDecoded.value instanceof Product && 
+console.log('Match:', isProduct(unitDecoded.value) &&
             Object.keys(unitDecoded.value.product).length === 0);
 
 // Test 2: Bool false
 console.log('\n=== Test 2: Bool (false) ===');
-const falseValue = new Variant('false', new Product({}));
+const falseValue = Value.variant('false', Value.product({}));
 console.log('Encoding false:', falseValue.toString());
 
 const boolPattern = patternToPropertyList(deriveClosedPattern(boolTypeName, boolTypeDef, resolveType));
@@ -69,12 +69,12 @@ console.log('Hex:', falseEncoded.toString('hex'));
 
 const falseDecoded = decodeWire(falseEncoded);
 console.log('Decoded value:', falseDecoded.value.toString());
-console.log('Match:', falseDecoded.value instanceof Variant && 
+console.log('Match:', isVariant(falseDecoded.value) &&
             falseDecoded.value.tag === 'false');
 
 // Test 3: Bool true
 console.log('\n=== Test 3: Bool (true) ===');
-const trueValue = new Variant('true', new Product({}));
+const trueValue = Value.variant('true', Value.product({}));
 console.log('Encoding true:', trueValue.toString());
 
 const trueEncoded = encodeToWire(trueValue, boolPattern);
@@ -83,7 +83,7 @@ console.log('Hex:', trueEncoded.toString('hex'));
 
 const trueDecoded = decodeWire(trueEncoded);
 console.log('Decoded value:', trueDecoded.value.toString());
-console.log('Match:', trueDecoded.value instanceof Variant && 
+console.log('Match:', isVariant(trueDecoded.value) &&
             trueDecoded.value.tag === 'true');
 
 console.log('\n=== All tests complete ===');

package/codecs/runtime/typeFromValue.mjs

@@ -1,4 +1,4 @@
-import { Product, Variant } from "../../Value.mjs";
+import { isProduct, isVariant } from "../../Value.mjs";
 
 function typeDefsFromValue(value) {
   let nextId = 0;
@@ -6,7 +6,7 @@ function typeDefsFromValue(value) {
 
   function visit(node) {
     const name = `:auto${nextId++}`;
-    if (node instanceof Product) {
+    if (isProduct(node)) {
       const labels = Object.keys(node.product).sort();
       const product = {};
       for (const label of labels) {
@@ -16,7 +16,7 @@ function typeDefsFromValue(value) {
       return name;
     }
 
-    if (node instanceof Variant) {
+    if (isVariant(node)) {
       const childName = visit(node.value);
       defs[name] = { code: "union", union: { [node.tag]: childName } };
       return name;
@@ -31,4 +31,4 @@ function typeDefsFromValue(value) {
 }
 
 export { typeDefsFromValue };
-export default { typeDefsFromValue };
+export default { typeDefsFromValue };

package/codecs/runtime/unicode-string.mjs

@@ -1,22 +1,22 @@
-import { Product, Variant } from "../../Value.mjs";
+import { Value, isProduct, isVariant } from "../../Value.mjs";
 
-const UNIT = new Product({});
-const BIT0 = new Variant("0", UNIT);
-const BIT1 = new Variant("1", UNIT);
+const UNIT = Value.product({});
+const BIT0 = Value.variant("0", UNIT);
+const BIT1 = Value.variant("1", UNIT);
 
 function bitValue(bit) {
   return bit === 0 ? BIT0 : BIT1;
 }
 
 function requireProduct(value, where) {
-  if (!(value instanceof Product)) {
+  if (!isProduct(value)) {
     throw new Error(`${where}: expected Product`);
   }
   return value.product;
 }
 
 function requireVariant(value, where) {
-  if (!(value instanceof Variant)) {
+  if (!isVariant(value)) {
     throw new Error(`${where}: expected Variant`);
   }
   return value;
@@ -27,7 +27,7 @@ function bitsProduct(width, n) {
   for (let i = width - 1; i >= 0; i--) {
     product[String(i)] = bitValue((n >> i) & 1);
   }
-  return new Product(product);
+  return Value.product(product);
 }
 
 function parseBitsProduct(value, maxBit, where) {
@@ -52,14 +52,14 @@ function parseByteProduct(value, where) {
 }
 
 function encodeBmpCommonHi(hi) {
-  if (hi >= 0x08 && hi <= 0x0f) return new Variant("h08_0F", bitsProduct(3, hi - 0x08));
-  if (hi >= 0x10 && hi <= 0x7f) return new Variant("h10_7F", bitsProduct(7, hi - 0x10));
-  if (hi >= 0x80 && hi <= 0xcf) return new Variant("h80_CF", bitsProduct(7, hi - 0x80));
-  if (hi >= 0xd0 && hi <= 0xd7) return new Variant("hD0_D7", bitsProduct(3, hi - 0xd0));
-  if (hi === 0xf9) return new Variant("hF9", UNIT);
-  if (hi >= 0xfa && hi <= 0xfb) return new Variant("hFA_FB", bitsProduct(1, hi - 0xfa));
-  if (hi >= 0xfc && hi <= 0xfd) return new Variant("hFC_FD", bitsProduct(1, hi - 0xfc));
-  if (hi >= 0xfe && hi <= 0xff) return new Variant("hFE_FF", bitsProduct(1, hi - 0xfe));
+  if (hi >= 0x08 && hi <= 0x0f) return Value.variant("h08_0F", bitsProduct(3, hi - 0x08));
+  if (hi >= 0x10 && hi <= 0x7f) return Value.variant("h10_7F", bitsProduct(7, hi - 0x10));
+  if (hi >= 0x80 && hi <= 0xcf) return Value.variant("h80_CF", bitsProduct(7, hi - 0x80));
+  if (hi >= 0xd0 && hi <= 0xd7) return Value.variant("hD0_D7", bitsProduct(3, hi - 0xd0));
+  if (hi === 0xf9) return Value.variant("hF9", UNIT);
+  if (hi >= 0xfa && hi <= 0xfb) return Value.variant("hFA_FB", bitsProduct(1, hi - 0xfa));
+  if (hi >= 0xfc && hi <= 0xfd) return Value.variant("hFC_FD", bitsProduct(1, hi - 0xfc));
+  if (hi >= 0xfe && hi <= 0xff) return Value.variant("hFE_FF", bitsProduct(1, hi - 0xfe));
   throw new Error(`Unsupported BMP common hi byte: 0x${hi.toString(16)}`);
 }
 
@@ -77,9 +77,9 @@ function decodeBmpCommonHi(value) {
 }
 
 function encodeBmpPrivateHi(hi) {
-  if (hi >= 0xe0 && hi <= 0xef) return new Variant("hE0_EF", bitsProduct(4, hi - 0xe0));
-  if (hi >= 0xf0 && hi <= 0xf7) return new Variant("hF0_F7", bitsProduct(3, hi - 0xf0));
-  if (hi === 0xf8) return new Variant("hF8", UNIT);
+  if (hi >= 0xe0 && hi <= 0xef) return Value.variant("hE0_EF", bitsProduct(4, hi - 0xe0));
+  if (hi >= 0xf0 && hi <= 0xf7) return Value.variant("hF0_F7", bitsProduct(3, hi - 0xf0));
+  if (hi === 0xf8) return Value.variant("hF8", UNIT);
   throw new Error(`Unsupported BMP private-use hi byte: 0x${hi.toString(16)}`);
 }
 
@@ -92,10 +92,10 @@ function decodeBmpPrivateHi(value) {
 }
 
 function encodePlane2To16(plane) {
-  if (plane >= 2 && plane <= 3) return new Variant("p02_03", bitsProduct(1, plane - 2));
-  if (plane >= 4 && plane <= 7) return new Variant("p04_07", bitsProduct(2, plane - 4));
-  if (plane >= 8 && plane <= 15) return new Variant("p08_0F", bitsProduct(3, plane - 8));
-  if (plane === 16) return new Variant("p10", UNIT);
+  if (plane >= 2 && plane <= 3) return Value.variant("p02_03", bitsProduct(1, plane - 2));
+  if (plane >= 4 && plane <= 7) return Value.variant("p04_07", bitsProduct(2, plane - 4));
+  if (plane >= 8 && plane <= 15) return Value.variant("p08_0F", bitsProduct(3, plane - 8));
+  if (plane === 16) return Value.variant("p10", UNIT);
   throw new Error(`Plane out of range for supplementary_planes2_16: ${plane}`);
 }
 
@@ -117,34 +117,34 @@ function codePointToUnicodeValue(cp) {
   }
 
   if (cp <= 0x7f) {
-    return new Variant("ascii", bitsProduct(7, cp));
+    return Value.variant("ascii", bitsProduct(7, cp));
   }
 
   if (cp <= 0x7ff) {
-    return new Variant("plane0", bitsProduct(11, cp));
+    return Value.variant("plane0", bitsProduct(11, cp));
   }
 
   if (cp <= 0xffff) {
     const hi = (cp >> 8) & 0xff;
     const lo = cp & 0xff;
     if (hi >= 0xe0 && hi <= 0xf8) {
-      return new Variant("bmp_private_use", new Product({ hi: encodeBmpPrivateHi(hi), lo: byteProduct(lo) }));
+      return Value.variant("bmp_private_use", Value.product({ hi: encodeBmpPrivateHi(hi), lo: byteProduct(lo) }));
     }
-    return new Variant("bmp_common", new Product({ hi: encodeBmpCommonHi(hi), lo: byteProduct(lo) }));
+    return Value.variant("bmp_common", Value.product({ hi: encodeBmpCommonHi(hi), lo: byteProduct(lo) }));
   }
 
   const mid = (cp >> 8) & 0xff;
   const lo = cp & 0xff;
 
   if (cp <= 0x1ffff) {
-    return new Variant("supplementary_plane1", new Product({
+    return Value.variant("supplementary_plane1", Value.product({
       mid: byteProduct(mid),
       lo: byteProduct(lo)
     }));
   }
 
   const plane = cp >> 16;
-  return new Variant("supplementary_planes2_16", new Product({
+  return Value.variant("supplementary_planes2_16", Value.product({
     plane: encodePlane2To16(plane),
     mid: byteProduct(mid),
     lo: byteProduct(lo)
@@ -181,11 +181,11 @@ function unicodeValueToCodePoint(value) {
 }
 
 function textToStringValue(text) {
-  let out = new Variant("nil", UNIT);
+  let out = Value.variant("nil", UNIT);
   const chars = Array.from(text);
   for (let i = chars.length - 1; i >= 0; i--) {
     const cp = chars[i].codePointAt(0);
-    out = new Variant("cons", new Product({
+    out = Value.variant("cons", Value.product({
       car: codePointToUnicodeValue(cp),
       cdr: out
     }));

package/codecs/unit.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 import { stdin, stdout, argv, exit } from "node:process";
-import { Product } from "../Value.mjs";
+import { Value, isProduct } from "../Value.mjs";
 import { isMainEntrypoint } from "./runtime/cli-entry.mjs";
 import { decodeWire, encodeToWire } from "./runtime/prefix-codec.mjs";
 
@@ -28,15 +28,15 @@ function readAll(stream) {
 }
 
 function unitEncoding() {
-  return encodeToWire(new Product({}), UNIT_PATTERN);
+  return encodeToWire(Value.product({}), UNIT_PATTERN);
 }
 
 function parse() {
-  return new Product({});
+  return Value.product({});
 }
 
 function print(value) {
-  if (!(value instanceof Product) || Object.keys(value.product).length !== 0) {
+  if (!isProduct(value) || Object.keys(value.product).length !== 0) {
     throw new Error("Input is not a unit value");
   }
   return "{}";

package/index.mjs

@@ -1,5 +1,5 @@
 import { parse } from "./parser.mjs";
-import { Value, fromObject } from "./Value.mjs";
+import { fromObject, isValue } from "./Value.mjs";
 import { parseValue } from "./valueIO.mjs";
 import { compileTypes } from "./compiler.mjs";
 import run from "./run.mjs";
@@ -19,7 +19,7 @@ compile.doc = "Transforms k-script (string) into a function";
 
 function runScriptOnData(script, data, options = {}) {
   let parsedData;
-  if (data instanceof Value) {
+  if (isValue(data)) {
     parsedData = data;
   } else if (typeof data === "string") {
     parsedData = parseValue(data, null, null);

package/kvm.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import fs from "node:fs";
 import { argv, stdin, exit, stdout } from "node:process";
-import { Product, Variant, composePattern, withPattern } from "./Value.mjs";
+import { Value, composePattern, withPattern, isProduct, isVariant } from "./Value.mjs";
 import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import {
@@ -281,7 +281,7 @@ function executeInstruction(inst, registers, context) {
     }
     case "project_field": {
       const val = registers.get(inst.src);
-      if (!(val instanceof Product)) return undefined;
+      if (!isProduct(val)) return undefined;
       const fieldVal = val.product[inst.label];
       if (fieldVal === undefined) return undefined;
 
@@ -295,7 +295,7 @@ function executeInstruction(inst, registers, context) {
     }
     case "project_variant": {
       const val = registers.get(inst.src);
-      if (!(val instanceof Variant) || val.tag !== inst.tag) return undefined;
+      if (!isVariant(val) || val.tag !== inst.tag) return undefined;
 
       if (options.envelopeFree) {
         registers.set(inst.dest, val.value);
@@ -308,11 +308,11 @@ function executeInstruction(inst, registers, context) {
     case "make_variant": {
       const val = registers.get(inst.src);
       if (options.envelopeFree) {
-        registers.set(inst.dest, new Variant(inst.tag, val));
+        registers.set(inst.dest, Value.variant(inst.tag, val));
       } else {
         registers.set(
           inst.dest,
-          new Variant(inst.tag, val, composePattern("open-union", [[inst.tag, val.pattern]]))
+          Value.variant(inst.tag, val, composePattern("open-union", [[inst.tag, val.pattern]]))
         );
       }
       return { type: "continue" };
@@ -375,13 +375,13 @@ function executeInstruction(inst, registers, context) {
       }
       let productValue;
       if (options.envelopeFree) {
-        productValue = new Product(result);
+        productValue = Value.product(result);
       } else {
         const staticOutputPattern = inst.pattern;
         if (staticOutputPattern) {
-          productValue = new Product(result, staticOutputPattern);
+          productValue = Value.product(result, staticOutputPattern);
         } else {
-          productValue = new Product(result, composePattern("closed-product", patternEntries));
+          productValue = Value.product(result, composePattern("closed-product", patternEntries));
         }
       }
       registers.set(inst.dest, productValue);

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.2.4",
+    "version": "6.3.1",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {

package/repl.mjs

@@ -10,7 +10,7 @@ import { argv, exit, stdin, stdout } from "node:process";
 import { annotate, parse } from "./index.mjs";
 import run from "./run.mjs";
 import codes from "./codes.mjs";
-import { Product } from "./Value.mjs";
+import { Value } from "./Value.mjs";
 import { patterns2filters, prettyCode, prettyRel } from "./pretty.mjs";
 import {
   compileObject,
@@ -50,7 +50,7 @@ function cloneJSON(value) {
 }
 
 function emptyValue() {
-  return new Product({}, [["closed-product", []]]);
+  return Value.product({}, [["closed-product", []]]);
 }
 
 function createState() {

package/run.mjs

@@ -1,5 +1,5 @@
 import assert from "assert";
-import { Product, Variant, edgeSubpattern, composePattern, withPattern } from "./Value.mjs"
+import { Value, edgeSubpattern, composePattern, withPattern, isProduct, isVariant } from "./Value.mjs"
 import { exportPatternGraph, intersectPropertyListPatterns } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 
@@ -261,14 +261,14 @@ function compiledExp(findCode, exp, typePatternGraph) {
             ` - product envelope: ${patternPreview(dynamicOutputPattern)}`
           );
         }
-        return new Product(result, pattern);
+        return Value.product(result, pattern);
       };
       break;
     }
     case "vid":
       fn = (value) => {
         if (value === undefined) return undefined;
-        return new Variant(exp.vid, value, composePattern("open-union", [[exp.vid, value.pattern]]));
+        return Value.variant(exp.vid, value, composePattern("open-union", [[exp.vid, value.pattern]]));
       };
       break;
     default:
@@ -375,13 +375,13 @@ function compiledConvergedExp(findCode, exp, typePatternGraph, options = {}) {
       break;
     case "dot":
       fn = (value) => {
-        if (value === undefined || !(value instanceof Product)) return undefined;
+        if (value === undefined || !isProduct(value)) return undefined;
         return Object.hasOwn(value.product, exp.dot) ? value.product[exp.dot] : undefined;
       };
       break;
     case "div":
       fn = (value) => {
-        if (value === undefined || !(value instanceof Variant) || value.tag !== exp.div) return undefined;
+        if (value === undefined || !isVariant(value) || value.tag !== exp.div) return undefined;
         return value.value;
       };
       break;
@@ -419,12 +419,12 @@ function compiledConvergedExp(findCode, exp, typePatternGraph, options = {}) {
           if (r === undefined) return undefined;
           result[labels[i]] = r;
         }
-        return new Product(result);
+        return Value.product(result);
       };
       break;
     }
     case "vid":
-      fn = (value) => value === undefined ? undefined : new Variant(exp.vid, value);
+      fn = (value) => value === undefined ? undefined : Value.variant(exp.vid, value);
       break;
     default:
       assert(false,`Unknown operation: '${exp.op}'`);
@@ -440,7 +440,7 @@ function verify(findCode, code, value) {
   code = findCode(code);
   switch (code.code) {
     case "product":
-      if (! (value instanceof Product)) return false;
+      if (!isProduct(value)) return false;
       else {
         const fields = Object.keys(value.product);
         if (fields.length !== Object.keys(code.product).length) return false;
@@ -449,7 +449,7 @@ function verify(findCode, code, value) {
         );
       }
     case "union":
-      if (! (value instanceof Product)) return false;
+      if (!isProduct(value)) return false;
       else {
         const fields = Object.keys(value.product);
         if (fields.length !== 1) return false;

package/scripts/run-tests.mjs

@@ -18,6 +18,7 @@ const tests = [
   ["tests/test-fingerprint.mjs", node, ["tests/test-fingerprint.mjs"]],
   ["tests/test-hash-fuzz.mjs", node, ["tests/test-hash-fuzz.mjs"]],
   ["tests/test-hash-normalization.mjs", node, ["tests/test-hash-normalization.mjs"]],
+  ["tests/test-structural-values.mjs", node, ["tests/test-structural-values.mjs"]],
   ["tests/test-deep-wire-value.mjs", node, ["tests/test-deep-wire-value.mjs"]],
   ["tests/test-k-object.mjs", node, ["tests/test-k-object.mjs"]],
   ["tests/test-repl.mjs", node, ["tests/test-repl.mjs"]],

package/tests/code-derivation/codec-witness-pattern.mjs

@@ -1,7 +1,7 @@
 import assert from 'assert';
 import { parseValue } from '../../valueIO.mjs';
 import { encodeToWire, decodeWire } from '../../codecs/runtime/prefix-codec.mjs';
-import { Product, Variant } from '../../Value.mjs';
+import { isProduct, isVariant } from '../../Value.mjs';
 
 const value = parseValue('{a:{b:x,c:{}}}');
 const repeatedClosedValue = parseValue('{a:{m:{},n:{}},b:{m:{},n:{}}}');
@@ -27,9 +27,9 @@ assert.deepEqual(explicitProductWire.pattern, [
 ]);
 
 const decoded = explicitProductWire.value;
-assert(decoded instanceof Product);
-assert(decoded.product.a instanceof Product);
-assert(decoded.product.a.product.b instanceof Variant);
+assert(isProduct(decoded));
+assert(isProduct(decoded.product.a));
+assert(isVariant(decoded.product.a.product.b));
 assert.equal(decoded.product.a.product.b.tag, "x");
 
 const repeatedClosedWire = decodeWire(encodeToWire(repeatedClosedValue, null));

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/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 = {}) {