@fraczak/k 6.0.0 → 6.0.2

package/test-repl2.mjs

@@ -2,8 +2,20 @@ import assert from "node:assert";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-
-import { completeInput, createState, evaluateInput } from "./repl2.mjs";
+import { fileURLToPath } from "node:url";
+
+import {
+  aliasNames,
+  analyzeAcceptedSnippet,
+  analyzeRawSnippet,
+  completeInput,
+  createState,
+  evaluateInput,
+  explicitSnippetTerminated,
+  isMainEntrypoint,
+  lineHasExplicitContinuation,
+  lineTerminatesSnippet
+} from "./repl2.mjs";
 import { decodeObject, objectToFunction } from "./object.mjs";
 import { Product } from "./Value.mjs";
 
@@ -40,11 +52,38 @@ assert(completions.some((line) => line.endsWith(state.typeAliases.nat)));
 completions = completeInput(`(${canonicalPartial}`, state)[0];
 assert(completions.includes(`(${state.typeAliases.nat}`));
 
+completions = completeInput(":run su", state)[0];
+assert(completions.includes(":run succ"));
+
+completions = completeInput("$na", state)[0];
+assert(completions.includes("$nat"));
+
+assert.deepEqual(aliasNames(state), ["nat", "succ"]);
+assert.equal(lineTerminatesSnippet(";"), true);
+assert.equal(lineTerminatesSnippet("  ;   "), true);
+assert.equal(lineTerminatesSnippet("  ;   -- comment"), false);
+assert.equal(lineTerminatesSnippet("succ"), false);
+assert.equal(explicitSnippetTerminated("$ bool = <{} true, {} false>;"), true);
+assert.equal(lineHasExplicitContinuation("succ \\"), true);
+assert.equal(analyzeRawSnippet("$ bool = <{} true, {} false>").kind, "incomplete");
+assert.equal(analyzeAcceptedSnippet("$ bool = <{} true, {} false>;", true).kind, "definitionsOnly");
+assert.equal(analyzeRawSnippet("a =").kind, "incomplete");
+assert.equal(analyzeRawSnippet("{} | succ").kind, "withMain");
+
+const offsetState = createState();
+await evaluateInput(":type ab = <{} 1, {} 2>", offsetState);
+await evaluateInput(":type bool = <{} true, {} false>", offsetState);
+await assert.rejects(
+  () => evaluateInput("$ab", offsetState),
+  /Type Error in 'filter' \(lines 1:1\.\.\.1:4\)/
+);
+
 const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl2-"));
 const libPath = path.join(tmpDir, "session.klib");
 const koPath = path.join(tmpDir, "succ.ko");
 const sourcePath = path.join(tmpDir, "session.k");
-output = await evaluateInput(`:save ${libPath}`, state);
+const symlinkPath = path.resolve(".test-k-repl2-link");
+output = await evaluateInput(`:klib ${libPath}`, state);
 assert.equal(output[0], `saved ${libPath}`);
 
 completions = completeInput(`:load ${tmpDir}/ses`, state)[0];
@@ -65,6 +104,14 @@ assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", loadedSource);
 assert.match(output[0], /^succ = @/m);
 
+const replPath = fileURLToPath(new URL("./repl2.mjs", import.meta.url));
+try {
+  fs.rmSync(symlinkPath, { force: true });
+} catch {}
+fs.symlinkSync(replPath, symlinkPath);
+fs.chmodSync(replPath, 0o755);
+assert.equal(isMainEntrypoint(symlinkPath), true);
+
 const reloaded = createState();
 output = await evaluateInput(`:load ${libPath}`, reloaded);
 assert.equal(output[0], `loaded ${libPath}`);
@@ -79,12 +126,22 @@ output = await evaluateInput("succ", reloaded);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
 const shorthand = createState();
-output = await evaluateInput("$ nat = <{} zero, nat succ>;", shorthand);
-assert.match(output[0], /^\$ nat = @/);
-output = await evaluateInput("succ = |succ;", shorthand);
-assert.match(output[0], /^succ = @/);
-output = await evaluateInput("succ", shorthand);
-assert.equal(output[0], "{}|succ ?<{} succ, ...>");
+output = await evaluateInput("$ nat = <{} zero, nat succ>\n; succ = |succ\n;", shorthand);
+assert.deepEqual(output, []);
+output = await evaluateInput(":codes", shorthand);
+assert.match(output[0], /^nat = @/m);
+output = await evaluateInput(":rels", shorthand);
+assert.match(output[0], /^succ = @/m);
+output = await evaluateInput("$ bool = <{} true, {} false>\n; not = $bool </true | false, {} | true >\n; {} | true not", shorthand);
+assert.match(output[0], /^\{\}\|false \?</);
+assert.match(output[0], / false/);
+assert.match(output[0], / true/);
+output = await evaluateInput("$ maybe = <{} none, {} some>;", shorthand);
+assert.deepEqual(output, []);
+output = await evaluateInput(":codes", shorthand);
+assert.match(output[0], /^maybe = @/m);
+output = await evaluateInput("{} | true not", shorthand);
+assert.match(output[0], /^\{\}\|false \?</);
 
 await assert.rejects(
   () => evaluateInput("/type", createState()),
@@ -92,4 +149,5 @@ await assert.rejects(
 );
 
 fs.rmSync(tmpDir, { recursive: true, force: true });
+fs.rmSync(symlinkPath, { force: true });
 console.log("OK");

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); };
+
+%%
+