@fraczak/k 6.8.0 → 6.10.1

package/codecs/example-pipeline.mjs

@@ -1,163 +0,0 @@
-#!/usr/bin/env node
-/**
- * Example: Demonstrating the codec pipeline
- * 
- * Shows how to:
- * 1. Define types with canonical names
- * 2. Create values
- * 3. Encode to binary
- * 4. Pass through "compiled program" (identity)
- * 5. Decode from binary
- * 6. Print result
- */
-
-import { deriveClosedPattern } from './runtime/codec.mjs';
-import { encodeToWire, decodeWire } from './runtime/prefix-codec.mjs';
-import { patternToPropertyList } from './runtime/pattern-json.mjs';
-import { Value, isVariant } from '../Value.mjs';
-import hash from '../hash.mjs';
-import { argv, exit } from 'node:process';
-
-function usage() {
-  console.log(`Usage: ${argv[1]}`);
-  console.log("       Run a self-contained demonstration of the codec pipeline.");
-  console.log("");
-  console.log("Options:");
-  console.log("  -h, --help   Show this help.");
-}
-
-if (argv.slice(2).includes("-h") || argv.slice(2).includes("--help")) {
-  usage();
-  exit(0);
-}
-
-console.log('=== K Codec Pipeline Example ===\n');
-
-// ============================================================================
-// Step 1: Define types (normally from compiler)
-// ============================================================================
-
-const types = {};
-
-// Unit: {}
-const unitDef = { code: 'product', product: {} };
-const unitName = hash('$C0={};');
-types[unitName] = unitDef;
-
-// Bool: <{} false, {} true>
-const boolDef = {
-  code: 'union',
-  union: { false: unitName, true: unitName }
-};
-const boolName = hash(`$C0=<${unitName}"false",${unitName}"true">;`);
-types[boolName] = boolDef;
-
-// Maybe: <{} nothing, Bool something>
-const maybeDef = {
-  code: 'union',
-  union: { nothing: unitName, something: boolName }
-};
-const maybeName = hash(
-  `$C0=<${unitName}"nothing",${boolName}"something">;`
-);
-types[maybeName] = maybeDef;
-
-console.log('Types defined:');
-console.log('  unit:', unitName);
-console.log('  bool:', boolName);
-console.log('  maybe:', maybeName);
-console.log();
-
-// ============================================================================
-// Step 2: Type resolver
-// ============================================================================
-
-function resolveType(typeName) {
-  const def = types[typeName];
-  if (!def) {
-    throw new Error(`Unknown type: ${typeName}`);
-  }
-  return def;
-}
-
-// ============================================================================
-// Step 3: Create input value: Maybe Bool = something(true)
-// ============================================================================
-
-const inputValue = Value.variant(
-  'something',
-  Value.variant('true', Value.product({}))
-);
-
-console.log('Input value:', inputValue.toString());
-console.log();
-
-const maybePattern = patternToPropertyList(
-  deriveClosedPattern(maybeName, maybeDef, resolveType)
-);
-
-// ============================================================================
-// Step 4: Parse (TEXT → BINARY)
-// ============================================================================
-
-console.log('--- PARSE (text → binary) ---');
-const binaryInput = encodeToWire(inputValue, maybePattern);
-console.log('Binary size:', binaryInput.length, 'bytes');
-console.log('  Bytes:', binaryInput.toString('hex'));
-console.log();
-
-// ============================================================================
-// Step 5: Compiled k-program (BINARY → BINARY)
-// ============================================================================
-
-console.log('--- COMPILED PROGRAM (binary → binary) ---');
-
-// Simulate a compiled k-program: decode → transform → encode
-const { value: programInput } = decodeWire(binaryInput);
-
-console.log('Program sees value:', programInput.toString());
-
-// Example transformation: NOT operation (flip bool inside Maybe)
-let programOutput;
-if (isVariant(programInput) && programInput.tag === 'something') {
-  const innerBool = programInput.value;
-  if (isVariant(innerBool)) {
-    const flipped = Value.variant(
-      innerBool.tag === 'true' ? 'false' : 'true',
-      innerBool.value
-    );
-    programOutput = Value.variant('something', flipped);
-  }
-} else {
-  programOutput = programInput; // nothing → nothing
-}
-
-console.log('Program output value:', programOutput.toString());
-
-// Encode output
-const binaryOutput = encodeToWire(programOutput, maybePattern);
-
-console.log('Binary output size:', binaryOutput.length, 'bytes');
-console.log('  Bytes:', binaryOutput.toString('hex'));
-console.log();
-
-// ============================================================================
-// Step 6: Print (BINARY → TEXT)
-// ============================================================================
-
-console.log('--- PRINT (binary → text) ---');
-const { value: finalValue } = decodeWire(binaryOutput);
-
-console.log('Output value:', finalValue.toString());
-console.log();
-
-// ============================================================================
-// Summary
-// ============================================================================
-
-console.log('=== Pipeline Summary ===');
-console.log('Input:  ', inputValue.toString(), '(true inside Maybe)');
-console.log('Transform: NOT operation on inner bool');
-console.log('Output: ', finalValue.toString(), '(false inside Maybe)');
-console.log();
-console.log('Binary representations are canonical and type-safe!');

package/codecs/runtime/ieee-pattern.mjs

@@ -1,30 +0,0 @@
-import fs from "node:fs";
-import { parse as parseScript } from "../../parser.mjs";
-import codes from "../../codes.mjs";
-import { deriveClosedPattern } from "./codec.mjs";
-import { patternToPropertyList } from "./pattern-json.mjs";
-
-const IEEE_SCRIPT = fs.readFileSync(new URL("../../Examples/ieee.k", import.meta.url), "utf8");
-
-function loadFloat64Pattern() {
-  const { defs } = parseScript(IEEE_SCRIPT);
-  const { codes: finalizedCodes, representatives } = codes.finalize(defs.codes);
-  const typeName = representatives.float64 || "float64";
-  const typeInfo = finalizedCodes[typeName];
-  if (!typeInfo) {
-    throw new Error("Could not resolve float64 type from Examples/ieee.k");
-  }
-  const resolveType = (name) => {
-    const type = finalizedCodes[name];
-    if (!type) {
-      throw new Error(`Unknown IEEE helper type '${name}'`);
-    }
-    return type;
-  };
-  return patternToPropertyList(deriveClosedPattern(typeName, typeInfo, resolveType));
-}
-
-const FLOAT64_PATTERN = loadFloat64Pattern();
-
-export { FLOAT64_PATTERN, loadFloat64Pattern };
-export default { FLOAT64_PATTERN, loadFloat64Pattern };

package/codecs/runtime/test-codec.mjs

@@ -1,89 +0,0 @@
-#!/usr/bin/env node
-/**
- * Test the binary codec with basic k types
- */
-
-import { deriveClosedPattern } from './codec.mjs';
-import { encodeToWire, decodeWire } from './prefix-codec.mjs';
-import { patternToPropertyList } from './pattern-json.mjs';
-import { Value, isProduct, isVariant } from '../../Value.mjs';
-import hash from '../../hash.mjs';
-
-// Type repository
-const types = {};
-
-// Define unit type: {}
-const unitTypeDef = { code: 'product', product: {} };
-const unitTypeStr = '$C0={};';
-const unitTypeName = hash(unitTypeStr);
-types[unitTypeName] = unitTypeDef;
-
-console.log('Unit type name:', unitTypeName);
-
-// Define bool type: <{} false, {} true>
-const boolTypeDef = {
-  code: 'union',
-  union: {
-    false: unitTypeName,
-    true: unitTypeName
-  }
-};
-const boolTypeStr = `$C0=<${unitTypeName}"false",${unitTypeName}"true">;`;
-const boolTypeName = hash(boolTypeStr);
-types[boolTypeName] = boolTypeDef;
-
-console.log('Bool type name:', boolTypeName);
-
-// Resolver function
-function resolveType(typeName) {
-  if (!types[typeName]) {
-    throw new Error(`Unknown type: ${typeName}`);
-  }
-  return types[typeName];
-}
-
-// Test 1: Unit value
-console.log('\n=== Test 1: Unit ===');
-const unitValue = Value.product({});
-console.log('Encoding unit:', unitValue.toString());
-
-const unitPattern = patternToPropertyList(deriveClosedPattern(unitTypeName, unitTypeDef, resolveType));
-const unitEncoded = encodeToWire(unitValue, unitPattern);
-console.log('Encoded bytes:', unitEncoded.length, 'bytes');
-console.log('Hex:', unitEncoded.toString('hex'));
-
-const unitDecoded = decodeWire(unitEncoded);
-console.log('Decoded value:', unitDecoded.value.toString());
-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 = Value.variant('false', Value.product({}));
-console.log('Encoding false:', falseValue.toString());
-
-const boolPattern = patternToPropertyList(deriveClosedPattern(boolTypeName, boolTypeDef, resolveType));
-const falseEncoded = encodeToWire(falseValue, boolPattern);
-console.log('Encoded bytes:', falseEncoded.length, 'bytes');
-console.log('Hex:', falseEncoded.toString('hex'));
-
-const falseDecoded = decodeWire(falseEncoded);
-console.log('Decoded value:', falseDecoded.value.toString());
-console.log('Match:', isVariant(falseDecoded.value) &&
-            falseDecoded.value.tag === 'false');
-
-// Test 3: Bool true
-console.log('\n=== Test 3: Bool (true) ===');
-const trueValue = Value.variant('true', Value.product({}));
-console.log('Encoding true:', trueValue.toString());
-
-const trueEncoded = encodeToWire(trueValue, boolPattern);
-console.log('Encoded bytes:', trueEncoded.length, 'bytes');
-console.log('Hex:', trueEncoded.toString('hex'));
-
-const trueDecoded = decodeWire(trueEncoded);
-console.log('Decoded value:', trueDecoded.value.toString());
-console.log('Match:', isVariant(trueDecoded.value) &&
-            trueDecoded.value.tag === 'true');
-
-console.log('\n=== All tests complete ===');

package/codecs/runtime/typeFromValue.mjs

@@ -1,34 +0,0 @@
-import { isProduct, isVariant } from "../../Value.mjs";
-
-function typeDefsFromValue(value) {
-  let nextId = 0;
-  const defs = {};
-
-  function visit(node) {
-    const name = `:auto${nextId++}`;
-    if (isProduct(node)) {
-      const labels = Object.keys(node.product).sort();
-      const product = {};
-      for (const label of labels) {
-        product[label] = visit(node.product[label]);
-      }
-      defs[name] = { code: "product", product };
-      return name;
-    }
-
-    if (isVariant(node)) {
-      const childName = visit(node.value);
-      defs[name] = { code: "union", union: { [node.tag]: childName } };
-      return name;
-    }
-
-    throw new Error(`Unsupported runtime value node: ${node?.constructor?.name || typeof node}`);
-  }
-
-  const root = visit(value);
-  defs.__root__ = { code: "ref", ref: `@${root}` };
-  return { defs, root };
-}
-
-export { typeDefsFromValue };
-export default { typeDefsFromValue };