@fraczak/k 6.1.1 → 6.1.2

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
@@ -61,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"));
@@ -89,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}`);
@@ -117,6 +121,61 @@ 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 {
   fs.rmSync(symlinkPath, { force: true });

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

package/type_registry/registry.mjs~

@@ -0,0 +1,105 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import codes from '../codes.mjs';
+import { parse } from './typeParser.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REGISTRY_FILE = path.join(__dirname, 'registry.json');
+const PORT = 3001;
+
+// Load existing registry if it exists
+if (fs.existsSync(REGISTRY_FILE)) {
+    console.log('Loading existing registry...');
+    try {
+        const data = fs.readFileSync(REGISTRY_FILE, 'utf8');
+        const json = JSON.parse(data);
+        codes.load(json);
+        console.log(`Loaded ${Object.keys(json).length} types.`);
+    } catch (err) {
+        console.error('Error loading registry:', err);
+    }
+} else {
+    console.log('No existing registry found. Starting fresh.');
+}
+
+const server = http.createServer((req, res) => {
+    // Helper to send JSON response
+    const sendJSON = (data, status = 200) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+
+    // Helper to send Error
+    const sendError = (message, status = 400) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: message }));
+    };
+
+    // Route: POST
+    if (req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            try {
+                // 1. Parse the input string using the Jison parser
+                // The parser expects a string of type definitions
+                console.log("Received body:", body);
+                const definitions = parse(body);
+                console.log("Parsed definitions:", JSON.stringify(definitions, null, 2));
+
+                // 2. Register the parsed codes
+                // codes.register returns the representatives map { temp_name: canonical_hash }
+                const representatives = codes.register(definitions);
+
+                // Filter out generated names (_gen_...) and canonical names (@...)
+                const filteredRepresentatives = Object.fromEntries(
+                    Object.entries(representatives).filter(([key, value]) => 
+                        !key.startsWith('_gen_') && !key.startsWith('@')
+                    )
+                );
+
+                // 3. Save to disk
+                const dump = codes.dump();
+                fs.writeFileSync(REGISTRY_FILE, JSON.stringify(dump, null, 2));
+
+                // 4. Return the mapping
+                sendJSON(filteredRepresentatives);
+
+            } catch (err) {
+                console.error(err);
+                sendError(`Registration failed: ${err.message}`);
+            }
+        });
+    }
+    // Route: GET 
+    else if (req.method === 'GET') {
+        const typeId = req.url.split('/').pop();
+        console.log("Requested type ID:", typeId);
+        if (!typeId) {
+            sendError('Missing type ID');
+            return;
+        }
+        // Decode URI component in case @ is encoded
+        const decodedId = decodeURIComponent(typeId);
+        console.log("Decoded type ID:", decodedId);
+        
+        const typeDef = codes.find(decodedId);
+        if (typeDef.code === 'undefined') {
+            sendError('Type not found', 404);
+        } else {
+            sendJSON(typeDef);
+        }
+    }
+    // 404 Not Found
+    else {
+        sendError('Not Found', 404);
+    }
+});
+
+server.listen(PORT, () => {
+    console.log(`Type Registry running at http://localhost:${PORT}/`);
+});

package/type_registry/typeParser.jison~

@@ -0,0 +1,132 @@
+%{
+
+let defs = {};
+let genCount = 0;
+let genNameId;
+
+function genName() {
+  return `_gen_${genCount++}`;
+}
+
+function fromEscString(escString) {
+  const isSingleQuoted = escString.startsWith("'");
+  let str = escString.substring(1, escString.length - 1);
+  if (isSingleQuoted) {
+    str = str.replace(/\\'/g, "'");
+  } else {
+    str = str.replace(/\\"/g, '"');
+  }
+  str = str.replace(/\\\\/g, '\\');
+  str = str.replace(/\\\//g, '/');
+  str = str.replace(/\\b/g, '\b');
+  str = str.replace(/\\f/g, '\f');
+  str = str.replace(/\\n/g, '\n');
+  str = str.replace(/\\r/g, '\r');
+  str = str.replace(/\\t/g, '\t');
+  str = str.replace(/\\u([\dA-F]{4})/gi, (match, p1) => String.fromCharCode(parseInt(p1, 16)));
+
+  return str;
+}
+
+%}
+
+%lex
+
+%%
+\s+                                            /* blanks */
+"<"                                            return 'LA';
+">"                                            return 'RA';
+"{"                                            return 'LC';
+"}"                                            return 'RC';
+"="                                            return 'EQ';
+","                                            return 'COMMA';
+";"                                            return 'SC';
+"@"                                            return 'AT';
+"$"                                            return 'DOLLAR';
+\"([^"\\]|\\(.|\n))*\"|\'([^'\\]|\\(.|\n))*\'  return 'STRING';
+[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*                return 'NAME';
+<<EOF>>                                        return 'EOF';
+.                                              return 'INVALID';
+
+/lex
+
+%token NAME STRING
+%token LA RA LC RC EQ COMMA SC AT DOLLAR
+%token EOF
+
+%start expressions
+
+%%
+
+expressions
+    : initialize_defs definitions EOF
+        { return defs; }
+    ;
+
+initialize_defs
+    : /* empty */
+        { defs = {}; genCount = 0; }
+    ;
+
+definitions
+    : definition
+    | definitions definition
+    ;
+
+definition
+    : DOLLAR name EQ LA field_list RA SC
+        { defs[$2] = { code: 'union', union: $5 }; }
+    | DOLLAR name EQ LC field_list RC SC
+        { defs[$2] = { code: 'product', product: $5 }; }
+    ;
+
+type_expr
+    : LA field_list RA
+        { 
+          genNameId = genName();
+          defs[genNameId] = { code: 'union', union: $2 }; 
+          $$ = genNameId;
+        }
+    | LC field_list RC
+        { 
+          genNameId = genName();
+          defs[genNameId] = { code: 'product', product: $2 }; 
+          $$ = genNameId;
+        }
+    | ref
+        { $$ = $1; }
+    ;
+
+ref
+    : name
+        { $$ = $1; }
+    | AT name
+        { $$ = '@' + $2; }
+    ;
+
+field_list
+    : /* empty */
+        { $$ = {}; }
+    | field
+        { $$ = {}; $$[$1.label] = $1.type; }
+    | field_list COMMA field
+        { $$ = $1; $$[$3.label] = $3.type; }
+    ;
+
+field
+    : type_expr label
+        { $$ = { type: $1, label: $2 }; }
+    ;
+
+label
+    : name
+        { $$ = $1; }
+    | str
+        { $$ = $1; }
+    ;
+
+name: NAME { $$ = yytext; };
+str: STRING { $$ = fromEscString(yytext); };
+
+%%
+

package/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +0,0 @@
-<component name="ProjectCodeStyleConfiguration">
-  <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
-  </state>
-</component>

package/.idea/copilot.data.migration.agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="AskMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.ask2agent.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="Ask2AgentMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/copilot.data.migration.edit.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="EditMigrationStateService">
-    <option name="migrationStatus" value="COMPLETED" />
-  </component>
-</project>

package/.idea/k.iml

@@ -1,9 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<module type="JAVA_MODULE" version="4">
-  <component name="NewModuleRootManager" inherit-compiler-output="true">
-    <exclude-output />
-    <content url="file://$MODULE_DIR$" />
-    <orderEntry type="inheritedJdk" />
-    <orderEntry type="sourceFolder" forTests="false" />
-  </component>
-</module>

package/.idea/misc.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectRootManager">
-    <output url="file://$PROJECT_DIR$/out" />
-  </component>
-</project>

package/.idea/modules.xml

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="ProjectModuleManager">
-    <modules>
-      <module fileurl="file://$PROJECT_DIR$/.idea/k.iml" filepath="$PROJECT_DIR$/.idea/k.iml" />
-    </modules>
-  </component>
-</project>

package/.idea/vcs.xml

@@ -1,6 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project version="4">
-  <component name="VcsDirectoryMappings">
-    <mapping directory="" vcs="Git" />
-  </component>
-</project>

package/k_compiler/runtime.c

@@ -1,205 +0,0 @@
-#include "runtime.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-typedef enum {
-  K_NODE_PRODUCT = 1,
-  K_NODE_VARIANT = 2
-} KNodeKind;
-
-typedef struct {
-  const char *label;
-  KValue value;
-} KField;
-
-struct KNode {
-  KNodeKind kind;
-  const char *type_id;
-  union {
-    struct {
-      int field_count;
-      KField *fields;
-    } product;
-    struct {
-      const char *tag;
-      KValue child;
-    } variant;
-  } as;
-};
-
-static char *krt_strdup(const char *value) {
-  size_t len = strlen(value);
-  char *result = (char *)malloc(len + 1);
-  memcpy(result, value, len + 1);
-  return result;
-}
-
-static const char *krt_infer_variant_type(const char *label, KValue child) {
-  if (child == NULL) return "";
-  if (child->type_id != NULL && child->type_id[0] != '\0') {
-    return child->type_id;
-  }
-  if (strcmp(label, "zero") == 0 || strcmp(label, "succ") == 0) {
-    return "@w8iSHeQQE738vEmWNGja3FQWk3XuExQKZ2pbm8ApEdkF";
-  }
-  return "";
-}
-
-static KOpt krt_ok(KValue value) {
-  KOpt result;
-  result.ok = 1;
-  result.value = value;
-  return result;
-}
-
-static const char *json_extract_string(const char *json, const char *key) {
-  static char buffer[256];
-  char pattern[64];
-  const char *cursor;
-  const char *start;
-  size_t length = 0;
-
-  snprintf(pattern, sizeof(pattern), "\"%s\":\"", key);
-  cursor = strstr(json, pattern);
-  if (cursor == NULL) return NULL;
-  start = cursor + strlen(pattern);
-
-  while (start[length] != '\0' && start[length] != '"') {
-    if (start[length] == '\\' && start[length + 1] != '\0') {
-      length += 2;
-      continue;
-    }
-    length += 1;
-  }
-
-  if (length >= sizeof(buffer)) {
-    length = sizeof(buffer) - 1;
-  }
-  memcpy(buffer, start, length);
-  buffer[length] = '\0';
-  return buffer;
-}
-
-static KValue product_field(KValue input, const char *label) {
-  int index;
-  if (input == NULL || input->kind != K_NODE_PRODUCT) return NULL;
-  for (index = 0; index < input->as.product.field_count; index += 1) {
-    if (strcmp(input->as.product.fields[index].label, label) == 0) {
-      return input->as.product.fields[index].value;
-    }
-  }
-  return NULL;
-}
-
-KOpt krt_fail(void) {
-  KOpt result;
-  result.ok = 0;
-  result.value = NULL;
-  return result;
-}
-
-KOpt krt_return_input(KValue input) {
-  return krt_ok(input);
-}
-
-KValue krt_new_product(const char *type_id, int field_count, const char *const *labels, KValue const *values) {
-  int index;
-  KNode *node = (KNode *)calloc(1, sizeof(KNode));
-  node->kind = K_NODE_PRODUCT;
-  node->type_id = krt_strdup(type_id == NULL ? "" : type_id);
-  node->as.product.field_count = field_count;
-  node->as.product.fields = field_count > 0 ? (KField *)calloc((size_t)field_count, sizeof(KField)) : NULL;
-
-  for (index = 0; index < field_count; index += 1) {
-    node->as.product.fields[index].label = krt_strdup(labels[index]);
-    node->as.product.fields[index].value = values[index];
-  }
-  return node;
-}
-
-KValue krt_new_variant(const char *type_id, const char *label, KValue child) {
-  KNode *node = (KNode *)calloc(1, sizeof(KNode));
-  node->kind = K_NODE_VARIANT;
-  node->type_id = krt_strdup(type_id == NULL ? "" : type_id);
-  node->as.variant.tag = krt_strdup(label);
-  node->as.variant.child = child;
-  return node;
-}
-
-KOpt krt_guard_code(KValue input, const char *type_id) {
-  if (input == NULL) return krt_fail();
-  if (type_id == NULL || type_id[0] == '\0') return krt_ok(input);
-  if (strcmp(input->type_id, type_id) == 0) return krt_ok(input);
-  return krt_fail();
-}
-
-KOpt krt_guard_type_var(KValue input, const char *var_name) {
-  (void)var_name;
-  if (input == NULL) return krt_fail();
-  return krt_ok(input);
-}
-
-KOpt krt_guard_shape(KValue input, const char *shape_descriptor_json) {
-  const char *shape;
-  if (input == NULL) return krt_fail();
-  shape = json_extract_string(shape_descriptor_json, "shape");
-  if (shape == NULL || strcmp(shape, "any") == 0) return krt_ok(input);
-  if (strcmp(shape, "product") == 0 && input->kind == K_NODE_PRODUCT) return krt_ok(input);
-  if (strcmp(shape, "union") == 0 && input->kind == K_NODE_VARIANT) return krt_ok(input);
-  return krt_fail();
-}
-
-KOpt krt_project_field(KValue input, const char *projection_descriptor_json) {
-  const char *label = json_extract_string(projection_descriptor_json, "label");
-  KValue child = product_field(input, label);
-  if (label == NULL || child == NULL) return krt_fail();
-  return krt_ok(child);
-}
-
-KOpt krt_project_variant(KValue input, const char *projection_descriptor_json) {
-  const char *label = json_extract_string(projection_descriptor_json, "label");
-  if (label == NULL || input == NULL || input->kind != K_NODE_VARIANT) return krt_fail();
-  if (strcmp(input->as.variant.tag, label) != 0) return krt_fail();
-  return krt_ok(input->as.variant.child);
-}
-
-KOpt krt_make_product(const char *type_id, int field_count, const char *const *labels, KValue const *values) {
-  return krt_ok(krt_new_product(type_id, field_count, labels, values));
-}
-
-KOpt krt_make_variant(KValue child, const char *label, const char *type_id) {
-  const char *resolved_type = type_id;
-  if (resolved_type == NULL || resolved_type[0] == '\0') {
-    resolved_type = krt_infer_variant_type(label, child);
-  }
-  return krt_ok(krt_new_variant(resolved_type, label, child));
-}
-
-void krt_print_value(KValue value) {
-  int index;
-  if (value == NULL) {
-    printf("<null>");
-    return;
-  }
-
-  if (value->kind == K_NODE_PRODUCT) {
-    if (value->as.product.field_count == 0) {
-      printf("{}");
-      return;
-    }
-    printf("{");
-    for (index = 0; index < value->as.product.field_count; index += 1) {
-      if (index > 0) printf(", ");
-      printf("%s:", value->as.product.fields[index].label);
-      krt_print_value(value->as.product.fields[index].value);
-    }
-    printf("}");
-    return;
-  }
-
-  printf("%s(", value->as.variant.tag);
-  krt_print_value(value->as.variant.child);
-  printf(")");
-}

package/k_compiler/runtime.h

@@ -1,34 +0,0 @@
-#ifndef K_COMPILER_RUNTIME_H
-#define K_COMPILER_RUNTIME_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct KNode KNode;
-typedef KNode *KValue;
-
-typedef struct {
-  int ok;
-  KValue value;
-} KOpt;
-
-KOpt krt_fail(void);
-KOpt krt_return_input(KValue input);
-KOpt krt_guard_code(KValue input, const char *type_id);
-KOpt krt_guard_type_var(KValue input, const char *var_name);
-KOpt krt_guard_shape(KValue input, const char *shape_descriptor_json);
-KOpt krt_project_field(KValue input, const char *projection_descriptor_json);
-KOpt krt_project_variant(KValue input, const char *projection_descriptor_json);
-KOpt krt_make_product(const char *type_id, int field_count, const char *const *labels, KValue const *values);
-KOpt krt_make_variant(KValue child, const char *label, const char *type_id);
-
-KValue krt_new_product(const char *type_id, int field_count, const char *const *labels, KValue const *values);
-KValue krt_new_variant(const char *type_id, const char *label, KValue child);
-void krt_print_value(KValue value);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif