@fraczak/k 5.1.2 → 6.0.1

package/unification.mjs

@@ -0,0 +1,157 @@
+function subsetP(v1,v2) {
+  const v2Set = new Set(v2);
+  return v1.every(x => v2Set.has(x));
+}
+
+function eqsetP(v1,v2) {
+  const v1Set = new Set(v1);
+  const v2Set = new Set(v2);
+  if (v1Set.size != v2Set.size) return false;
+
+  for (const value of v1Set) {
+    if (!v2Set.has(value)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+function setUnion(...vectors) {
+  const unionSet = new Set();
+  for (const v of vectors) {
+    for (const element of v) {
+      unionSet.add(element);
+    }
+  }
+  return Array.from(unionSet);
+}
+
+export function unify_two_patterns(findCode, p1, p2) {
+  // console.log(`unify_two_patterns(${JSON.stringify(p1)}, ${JSON.stringify(p2)})`);
+  if (p1.pattern === '()' || p2.pattern === '()') {
+    throw new Error("Closed unknown pattern '()' is not supported. Use '{}' or '<>' to choose product or union.");
+  }
+  if ((p1.pattern === '(...)' && (p1.fields || []).length !== 0) || (p2.pattern === '(...)' && (p2.fields || []).length !== 0)) {
+    throw new Error("Unknown-kind pattern '(...)' cannot have fields.");
+  }
+  switch (p1.pattern) {
+    case '(...)':
+      switch (p2.pattern) {
+        case '(...)':
+          return {...p2, fields: setUnion(p1.fields, p2.fields)};
+        case '{...}':
+          return {...p2, fields: setUnion(p1.fields, p2.fields)};
+        case '<...>':
+          return {...p2, fields: setUnion(p1.fields, p2.fields)};
+        case '{}':
+          if (subsetP(p1.fields, p2.fields)) return p2;
+          throw new Error(`Cannot unify (${p1.fields},...) with {${p2.fields}}`);
+        case '<>':
+          if (subsetP(p1.fields, p2.fields)) return p2;
+          throw new Error(`Cannot unify (${p1.fields},...) with <${p2.fields}>`);
+        case 'type': {
+            const code = findCode(p2.type);
+            // console.log(JSON.stringify({p1,p2,code}));
+            switch (code.code) {
+              case 'product':
+              case 'union': {
+                let p2_fields = Object.keys(code[code.code]);
+                if (subsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
+              }; break;
+            }
+            throw new Error(`Cannot unify ${JSON.stringify(p1)} with code ${p2.type}:${code.def}`);
+          }
+        } ;
+      break;
+    case '{...}':
+      switch (p2.pattern) {
+        case '{...}':
+          return {...p2, fields: setUnion(p1.fields, p2.fields)};
+        case '<...>':
+          throw new Error('Cannot unify {...} with <...>');
+        case '{}':
+          if (subsetP(p1.fields, p2.fields)) return p2;
+          throw new Error(`Cannot unify {${p1.fields},...} with {${p2.fields}}`);
+        case '<>':
+          throw new Error('Cannot unify {...} with <>');
+        case 'type': {
+          const code = findCode(p2.type);
+          switch (code.code) {
+            case 'product':{
+              let p2_fields = Object.keys(code[code.code]);
+              if (subsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
+            };
+          }
+          throw new Error(`Cannot unify ${JSON.stringify(p1)} with code ${p2.type}:${code.def}`);
+        }
+      };
+      break;
+    case '<...>':
+      switch (p2.pattern) {
+        case '<...>':
+          return {pattern: '<...>', fields: setUnion(p1.fields, p2.fields)};
+        case '{}':
+          throw new Error('Cannot unify <...> with {}');
+        case '<>':
+          if (subsetP(p1.fields, p2.fields)) return p2;
+          throw new Error(`Cannot unify <${p1.fields},...> with <${p2.fields}>`);
+        case 'type':{
+          const code = findCode(p2.type);
+          switch (code.code) {
+            
+            case 'union': {
+              let p2_fields = Object.keys(code[code.code]);
+              if (subsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
+            }
+          }
+          throw new Error(`Cannot unify ${JSON.stringify(p1)} with code ${p2.type}:${code.def}`);
+        };
+      }; 
+      break;
+    case '{}':
+      switch (p2.pattern) {
+        case '{}':
+          if (eqsetP(p1.fields, p2.fields)) return p2;
+          throw new Error(`Cannot unify {${p1.fields}} with {${p2.fields}}`);
+        case '<>':
+          throw new Error('Cannot unify {} with <>');
+        case 'type': {
+          const code = findCode(p2.type);
+          switch (code.code) {
+            case 'product':{
+              let p2_fields = Object.keys(code[code.code]);
+              if (eqsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
+            };
+          }
+          throw new Error(`Cannot unify ${JSON.stringify(p1)} with code ${p2.type}:${code.def}`);
+        }
+      };
+      break;
+    case '<>':
+      switch (p2.pattern) {
+        case '<>':
+          if (eqsetP(p1.fields, p2.fields)) return p2;
+          throw new Error(`Cannot unify <${p1.fields}> with <${p2.fields}>`);
+        case 'type': {
+          const code = findCode(p2.type);
+          switch (code.code) {
+            case 'union':{
+              let p2_fields = Object.keys(code[code.code]);
+              if (eqsetP(p1.fields, p2_fields)) return {...p2, fields: p2_fields};
+            };
+          }
+          throw new Error(`Cannot unify ${JSON.stringify(p1)} with code ${p2.type}:${code.def}`);
+        }
+      };
+      break;
+    case 'type':
+      switch (p2.pattern) {
+        case 'type': 
+          if (p1.type != p2.type)
+            throw new Error(`Cannot unify different types: ${p1.type}:${findCode(p1.type).def} and ${p2.type}:${findCode(p2.type).def}`);
+          return p2;
+      };
+      break;
+  }
+  return unify_two_patterns(findCode, p2, p1);
+}

package/valueIO.mjs

@@ -0,0 +1,54 @@
+/**
+ * Value I/O with Type Information
+ * 
+ * This module wraps the valueParser to support explicit type information.
+ * 
+ * Migration strategy (2 steps):
+ * - Step 1 (current): Add type parameter to all parseValue calls, but keep text parsing
+ * - Step 2 (future): Replace implementation to use binary codec
+ */
+
+import { parse as parseValueText } from "./valueParser.mjs";
+import { Value, fromObject } from "./Value.mjs";
+
+/**
+ * Parse a value from text with optional type information
+ * 
+ * @param {string} text - JSON-like text representation
+ * @param {string|null} typeName - Canonical type name (e.g., "@ABC123...")
+ * @param {Object|null} typeInfo - Type definition (for validation/future use)
+ * @returns {Value} - Product or Variant
+ * 
+ * Step 1: Type parameters are accepted but not yet used
+ * Step 2: Will validate against type and eventually parse binary format
+ */
+export function parseValue(text, typeName = null, typeInfo = null) {
+  // Step 1: Ignore type for now, just parse text as before
+  // TODO Step 2: Validate parsed value against typeInfo if provided
+  return parseValueText(text);
+}
+
+/**
+ * Serialize a value to text
+ * 
+ * @param {Value} value - Product or Variant
+ * @param {string|null} typeName - Canonical type name (optional)
+ * @param {Object|null} typeInfo - Type definition (optional)
+ * @returns {string} - JSON representation
+ * 
+ * Step 1: Returns JSON, ignoring type
+ * Step 2: Will encode to binary format
+ */
+export function printValue(value, typeName = null, typeInfo = null) {
+  // Step 1: Just serialize to JSON as before
+  // TODO Step 2: Encode to binary format using codec
+  return JSON.stringify(value);
+}
+
+/**
+ * Convert JavaScript object to k Value
+ * (No change needed - this is type-agnostic)
+ */
+export { fromObject } from "./Value.mjs";
+
+export default { parseValue, printValue, fromObject };

package/valueParser.jison

@@ -0,0 +1,143 @@
+%{
+
+import { Product, Variant } from "./Value.mjs";
+
+//--------------------------
+
+function anError(pos,msg) {
+    throw new Error(`Parse Error (lines ${pos.first_line}:${pos.first_column}...${pos.last_line}:${pos.last_column}): ${msg}`);
+}
+
+function getToken(yytext,yy,lstack) {
+    const yylloc = yy.lexer.yylloc;
+    const loc = lstack[lstack.length - 1]; //  { first_line: 5, last_line: 5, first_column: 2, last_column: 3 };
+    const start = {line: loc.first_line, column: loc.first_column + 1};
+    const end = {line: start.line, column: start.column + yytext.length};
+    const result = {start,end,value: String(yytext)};
+    // console.log(result);
+    return result;
+}
+
+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
+
+%%
+[/][*]([^*]*[*]+[^*/])*[^*]*[*]+[/]             /* c-comment */
+("//"|"#"|"%"|"--"|"\\")[^\n]*                  /* one line comment */
+\s+                                             /* blanks */
+"{"                                            return 'LC';
+"}"                                            return 'RC';
+"["                                            return 'LB';
+"]"                                            return 'RB';
+","                                            return 'COMMA';
+":"                                            return 'COL';
+\"([^"\\]|\\(.|\n))*\"|\'([^'\\]|\\(.|\n))*\'  return 'STRING';
+[a-zA-Z0-9_][a-zA-Z0-9_?!]*                    return 'NAME';
+<<EOF>>                                        return 'EOF';
+
+/lex
+
+%token NAME STRING
+%token  LC RC LB RB COMMA COL
+%token EOF
+
+%start input_with_eof
+
+%%
+
+str : STRING                            { $$ = getToken(yytext,yy,_$); $$.value = fromEscString($$.value);}
+    | NAME                              { $$ = getToken(yytext,yy,_$); }
+    ;
+lc: LC                                  { $$ = getToken(yytext,yy,_$); };
+rc: RC                                  { $$ = getToken(yytext,yy,_$); };
+lb: LB                                  { $$ = getToken(yytext,yy,_$); };
+rb: RB                                  { $$ = getToken(yytext,yy,_$); };
+comma: COMMA                            { $$ = getToken(yytext,yy,_$); };
+col: COL                                { $$ = getToken(yytext,yy,_$); };
+
+input_with_eof
+    : exp EOF   {
+                  // console.log(`Parsed: ${$1.value.toString()}`);
+                  return $1.value;
+                }
+    ;
+
+exp
+    : lc labelled rc                    { $$ = {value: $2.value, start: $1.start, end: $3.end}; }
+    | lb exps rb                        { $$ = {value: $2.value, start: $1.start, end: $3.end}; }
+    | str            { $$ = {value: new Variant($1.value, new Product({})), start: $1.start, end: $1.end}; }
+    | name           { $$ = {value: new Variant($1.value, new Product({})), start: $1.start, end: $1.end}; }
+    ;
+
+exps
+    : /* empty */                       { $$ = {value: new Product({})}; }
+    | non_empty_exps                    {
+                                          if ($1.list.length === 1) {
+                                            $$ = {value: new Variant('0', $1.list[0].value)};
+                                          } else {
+                                            const product = {};
+                                            $1.list.forEach( (e, i) => product[i] = e.value );
+                                            $$ = {value: new Product(product)};
+                                          };
+                                        }
+    ;
+
+non_empty_exps
+    : exp      { $$ = {list: [$1]} ; }
+    | non_empty_exps comma exp
+        { $$ = {list: [].concat($1.list,$3)}; }
+    ;
+
+labelled
+    : /* empty */                       { $$ = {value: new Product({})}; }
+    | non_empty_labelled                {
+                                          if ($1.list.length === 1) {
+                                            $$ = {value: new Variant($1.list[0].label, $1.list[0].value)};
+                                          } else {
+                                            const product = {};
+                                            for (const {label, value} of $1.list) {
+                                              if (product.hasOwnProperty(label))
+                                                anError(@0,`Duplicate label '${label}'.`);
+                                              product[label] = value;
+                                            }
+                                            $$ = {value: new Product(product)};
+                                          };
+                                        }
+    ;
+
+non_empty_labelled
+    : exp_label
+        { $$ = {list: [$1]} ; }
+    | non_empty_labelled comma exp_label
+        { $$ = {list: [].concat($1.list,$3)}; }
+    ;
+
+exp_label
+    : exp str   { $$ = {label: $2.value, value: $1.value}; }
+    | str col exp { $$ = {label: $1.value, value: $3.value}; }
+    | bits col exp { $$ = {label: $1.value, value: $3.value}; }
+    ;
+
+%%