@fraczak/k 6.1.0 → 6.1.1

package/.idea/codeStyles/codeStyleConfig.xml

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

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

@@ -0,0 +1,6 @@
+<?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

@@ -0,0 +1,6 @@
+<?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

@@ -0,0 +1,6 @@
+<?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

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

package/.idea/k.iml

@@ -0,0 +1,9 @@
+<?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

@@ -0,0 +1,6 @@
+<?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

@@ -0,0 +1,8 @@
+<?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

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

package/k_compiler/runtime.c

@@ -0,0 +1,205 @@
+#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

@@ -0,0 +1,34 @@
+#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

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.1.0",
+    "version": "6.1.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

@@ -261,10 +261,18 @@ function listAliases(aliases) {
   return entries.map(([name, hash]) => `${name} = ${hash}`).join("\n");
 }
 
-function printValue(value = null) {
+function printValue(value) {
   return valueWithEnvelopeToK(value);
 }
 
+function commitResult(state, result, lastMain) {
+  if (result !== undefined) {
+    state.value = result;
+    state.lastMain = lastMain;
+  }
+  return [printValue(result)];
+}
+
 function userDefinedNames(source) {
   let parsed;
   try {
@@ -347,6 +355,17 @@ function aliasNames(state) {
   ])].sort();
 }
 
+function displayAliases(state) {
+  const aliases = {};
+  for (const [name, hash] of [
+    ...Object.entries(state.typeAliases),
+    ...Object.entries(state.relAliases)
+  ].sort(([a], [b]) => a.localeCompare(b))) {
+    if (!aliases[hash]) aliases[hash] = name;
+  }
+  return aliases;
+}
+
 function expandHome(input) {
   if (input === "~") return os.homedir();
   if (input.startsWith("~/")) return path.join(os.homedir(), input.slice(2));
@@ -659,14 +678,14 @@ async function runExpression(input, state) {
   }
   const mainRel = annotated.rels.__main__;
   run.defs = annotated;
+  let result;
   try {
-    state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+    result = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
   } catch (error) {
     throw remapError(error, preambleLineCount(preamble));
   }
-  state.lastMain = expression;
   restoreCodes(state);
-  return [printValue(state.value)];
+  return commitResult(state, result, expression);
 }
 
 async function runSnippet(input, state, options = {}) {
@@ -685,14 +704,14 @@ async function runSnippet(input, state, options = {}) {
 
   const mainRel = annotated.rels.__main__;
   run.defs = annotated;
+  let result;
   try {
-    state.value = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
+    result = run(codes.find, mainRel.def, state.value, mainRel.typePatternGraph);
   } catch (error) {
     throw remapError(error, lineOffset);
   }
-  state.lastMain = snippet;
   restoreCodes(state);
-  return [printValue(state.value)];
+  return commitResult(state, result, snippet);
 }
 
 async function evaluateInput(input, state) {
@@ -803,13 +822,13 @@ async function evaluateCommand(line, state) {
       if (!arg) throw new Error(`${usagePrefix}d requires a relation name`);
       const { hash, rel } = resolveRel(state, arg);
       if (!rel) throw new Error(`Unknown relation '${arg}'`);
-      return [`${arg} = ${prettyRelation(rel)};  -- ${hash}`];
+      return [`${arg} = ${prettyRelation(rel, displayAliases(state), state.relAliases)};  -- ${hash}`];
     }
     case "C": {
       if (!arg) throw new Error(`${usagePrefix}C requires a type name`);
       const hash = state.typeAliases[arg] || (arg.startsWith("@") ? arg : null);
       if (!hash || !(hash in state.codes)) throw new Error(`Unknown type '${arg}'`);
-      return [`$ ${arg} = ${prettyCode({}, codes.find, codes.find(hash))};  -- ${hash}`];
+      return [`$ ${arg} = ${prettyCode(displayAliases(state), codes.find, codes.find(hash))};  -- ${hash}`];
     }
     default:
       throw new Error(`Unknown command ':${command}'. Try :help`);

package/test-repl.mjs

@@ -36,6 +36,13 @@ assert.match(output[0], /^succ = @/m);
 output = await evaluateInput(":run succ", state);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
+output = await evaluateInput("/zero", state);
+assert.equal(output[0], "... undefined");
+assert.equal(state.value.toJSON(), "succ");
+
+output = await evaluateInput("succ", state);
+assert.match(output[0], /^\{\}\|succ\|succ \?</);
+
 output = await evaluateInput(":t succ", state);
 assert.match(output[0], /^succ : /);
 
@@ -97,7 +104,7 @@ const objectFn = objectToFunction(decodeObject(fs.readFileSync(koPath)));
 const objectResult = objectFn(new Product({}, [["closed-product", []]]));
 assert.equal(objectResult.toJSON(), "succ");
 
-fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = |succ;\n");
+fs.writeFileSync(sourcePath, "$ nat = <{} zero, nat succ>;\nsucc = $nat |succ $nat;\ntwice = succ succ;\n");
 const loadedSource = createState();
 output = await evaluateInput(`:load ${sourcePath}`, loadedSource);
 assert.equal(output[0], `loaded ${sourcePath}`);
@@ -105,6 +112,10 @@ output = await evaluateInput(":codes", loadedSource);
 assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", loadedSource);
 assert.match(output[0], /^succ = @/m);
+output = await evaluateInput(":d twice", loadedSource);
+assert.match(output[0], /^twice = \$nat succ succ \$nat;  -- @/);
+output = await evaluateInput(":C nat", loadedSource);
+assert.match(output[0], /^\$ nat = < nat succ, @[^ ]+ zero >;  -- @/);
 
 const replPath = fileURLToPath(new URL("./repl.mjs", import.meta.url));
 try {