@fraczak/k 7.2.0 → 8.1.0

package/core.k

@@ -9,9 +9,11 @@
 -- §1. Bits
 ---------------------------------------------------------------
 
-bit? = ?< {} 0, {} 1 >;
+bit[] = < {} 0, {} 1 >;
+bits[] = < {} _, B 0, B 1 > = B;
 
-bits? = ?< {} _, bits? 0, bits? 1 > = bits?;
+bit? = ? bit[];
+bits? = ? bits[];
 
 _ = {}|_;
 
@@ -22,52 +24,66 @@ _ = {}|_;
 -- §2. Unicode and String
 ---------------------------------------------------------------
 
-string? = ? <
-  {} nil,
-  {
-    <
-      {
-        < {} 0, {} 1 >=Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6
-      }=Bits7 ascii,
-      {
-        <
-          { Bit 0, Bit 1, Bit 2 }=Bits3 h08_0F,
-          Bits7 h10_7F,
-          Bits7 h80_CF,
-          Bits3 hD0_D7,
-          {} hF9,
-          { Bit 0 }=Bits1 hFA_FB,
-          Bits1 hFC_FD,
-          Bits1 hFE_FF
-        > hi,
-        { Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7 }=Bits8 lo
-      } bmp_common,
-      {
-        <
-          { Bit 0, Bit 1, Bit 2, Bit 3 } hE0_EF,
-          Bits3 hF0_F7,
-          {} hF8
-        > hi,
-        Bits8 lo
-      } bmp_private_use,
-      {
-        Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7, Bit 8, Bit 9, Bit 10
-      } plane0,
-      { Bits8 mid, Bits8 lo } supplementary_plane1,
-      {
-        <
-          Bits1 p02_03,
-          { Bit 0, Bit 1 } p04_07,
-          Bits3 p08_0F,
-          {} p10
-        > plane,
-        Bits8 mid,
-        Bits8 lo
-      } supplementary_planes2_16
-    > car,
-    String cdr
-  } cons
-> = String;
+-- 8-bit octet used as a building block for UTF-8 payload pieces.
+byte[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6, bit[] 7
+};
+
+-- 7-bit ASCII code point payload (U+0000..U+007F).
+ascii[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3,
+  bit[] 4, bit[] 5, bit[] 6
+};
+
+-- High-byte classes for common BMP ranges, excluding surrogate
+-- and private-use partitions.
+bmp_hi_common[] = <
+  { bit[] 0, bit[] 1, bit[] 2 } h08_0F,
+  ascii[] h10_7F,
+  ascii[] h80_CF,
+  { bit[] 0, bit[] 1, bit[] 2 } hD0_D7,
+  {} hF9,
+  { bit[] 0 } hFA_FB,
+  { bit[] 0 } hFC_FD,
+  { bit[] 0 } hFE_FF
+>;
+
+-- High-byte classes for BMP private-use/high-reserved slices.
+bmp_hi_private_use[] = <
+  { bit[] 0, bit[] 1, bit[] 2, bit[] 3 } hE0_EF,
+  { bit[] 0, bit[] 1, bit[] 2 } hF0_F7,
+  {} hF8
+>;
+
+-- 11-bit payload used for Plane 0 code points U+0080..U+07FF.
+plane0[] = {
+  bit[] 0, bit[] 1, bit[] 2, bit[] 3, bit[] 4,
+  bit[] 5, bit[] 6, bit[] 7, bit[] 8, bit[] 9, bit[] 10
+};
+
+-- Plane selector for supplementary code points in Planes 2..16.
+plane_02_10[] = <
+  { bit[] 0 } p02_03,
+  { bit[] 0, bit[] 1 } p04_07,
+  { bit[] 0, bit[] 1, bit[] 2 } p08_0F,
+  {} p10
+>;
+
+-- Canonical Unicode scalar-value partition used by string encoding.
+unicode[] = <
+  ascii[] ascii,
+  { bmp_hi_common[] hi, byte[] lo } bmp_common,
+  { bmp_hi_private_use[] hi, byte[] lo } bmp_private_use,
+  plane0[] plane0,
+  { byte[] mid, byte[] lo } supplementary_plane1,
+  { plane_02_10[] plane, byte[] mid, byte[] lo } supplementary_planes2_16
+>;
+
+-- Linked-list string: nil or (unicode car, string cdr).
+string[] = < {} nil, { unicode[] car, S cdr } cons > = S;
+
+string? = ? string[];
 
 ---------------------------------------------------------------
 -- §3. Pattern
@@ -82,72 +98,20 @@ string? = ? <
 -- to decode any value, first decode a pattern under that constant,
 -- then decode the value under the pattern just obtained.
 
-pattern? = ? <
-  {} nil,
-  {
-    <
-      {} any,
-      <
-        {} nil,
-        {
-          {
-            <
-              {} nil,
-              {
-                <
-                  {
-                    < {} 0, {} 1 >=Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6
-                  }=Bits7 ascii,
-                  {
-                    <
-                      { Bit 0, Bit 1, Bit 2 }=Bits3 h08_0F,
-                      Bits7 h10_7F,
-                      Bits7 h80_CF,
-                      Bits3 hD0_D7,
-                      {} hF9,
-                      { Bit 0 }=Bits1 hFA_FB,
-                      Bits1 hFC_FD,
-                      Bits1 hFE_FF
-                    > hi,
-                    { Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7 }=Bits8 lo
-                  } bmp_common,
-                  {
-                    <
-                      { Bit 0, Bit 1, Bit 2, Bit 3 } hE0_EF,
-                      Bits3 hF0_F7,
-                      {} hF8
-                    > hi,
-                    Bits8 lo
-                  } bmp_private_use,
-                  {
-                    Bit 0, Bit 1, Bit 2, Bit 3, Bit 4, Bit 5, Bit 6, Bit 7, Bit 8, Bit 9, Bit 10
-                  } plane0,
-                  { Bits8 mid, Bits8 lo } supplementary_plane1,
-                  {
-                    <
-                      Bits1 p02_03,
-                      { Bit 0, Bit 1 } p04_07,
-                      Bits3 p08_0F,
-                      {} p10
-                    > plane,
-                    Bits8 mid,
-                    Bits8 lo
-                  } supplementary_planes2_16
-                > car,
-                String cdr
-              } cons
-            > = String label,
-            < Bits 0, Bits 1, {} _ > = Bits target
-          } car,
-          Edges cdr
-        } cons
-      > = Edges open-product,
-      Edges open-union,
-      Edges closed-product,
-      Edges closed-union
-    > car,
-    Pattern cdr
-  } cons
-> = Pattern;
+edge[] = { string[] label, bits[] target };
+
+edges[] = < {} nil, { edge[] car, E cdr } cons > = E;
+
+node[] = <
+  {} any,
+  edges[] open-product,
+  edges[] open-union,
+  edges[] closed-product,
+  edges[] closed-union
+>;
+
+pattern[] = < {} nil, { node[] car, P cdr } cons > = P;
+
+pattern? = ? pattern[];
 
 pattern?

package/index.mjs

@@ -2,6 +2,7 @@ import { parse } from "./parser.mjs";
 import { fromObject, isValue } from "./Value.mjs";
 import { parseValue } from "./valueIO.mjs";
 import { compileTypes } from "./compiler.mjs";
+import { expandPatternsInRels } from "./named-patterns.mjs";
 import run from "./run.mjs";
 import codes from "./codes.mjs";
 
@@ -37,6 +38,8 @@ function annotate(script, options = {}) {
   const representatives = codes.register(defs.codes);
   const rels = {...defs.rels, "__main__": {def: exp}};
 
+  expandPatternsInRels(rels, defs.patterns || {}, options);
+
   // Inject library relations into the rels table so @hash refs resolve
   if (options.libraries) {
     for (const lib of options.libraries) {

package/named-patterns.mjs

@@ -0,0 +1,267 @@
+// named-patterns.mjs
+// Expansion of named patterns and parameterized type schemes in k ASTs.
+
+function cloneFilter(filter) {
+  if (!filter || typeof filter !== "object") return filter;
+  const copy = { ...filter };
+  if (filter.fields) {
+    copy.fields = {};
+    for (const [k, v] of Object.entries(filter.fields)) {
+      copy.fields[k] = cloneFilter(v);
+    }
+  }
+  if (filter.args) {
+    copy.args = filter.args.map(cloneFilter);
+  }
+  return copy;
+}
+
+export function expandFilter(
+  filter,
+  patterns = {},
+  stack = new Set(),
+  uniqueIdRef = { val: 0 }
+) {
+  if (!filter || typeof filter !== "object") return filter;
+
+  if (filter.type === "pattern_apply") {
+    const patternName = filter.pattern;
+    const template = patterns[patternName];
+    if (!template) {
+      const pos = filter.start
+        ? ` (lines ${filter.start.line}:${filter.start.column})`
+        : "";
+      throw new Error(
+        `Unknown pattern template '${patternName}[]'${pos}`
+      );
+    }
+
+    if (stack.has(patternName)) {
+      const cycle = [...stack, patternName].join(" -> ");
+      throw new Error(
+        `Cyclic pattern template dependency detected: ${cycle}`
+      );
+    }
+
+    const expectedArity = template.params.length;
+    const actualArity = (filter.args || []).length;
+    if (expectedArity !== actualArity) {
+      const pos = filter.start
+        ? ` (lines ${filter.start.line}:${filter.start.column})`
+        : "";
+      throw new Error(
+        `Pattern '${patternName}' expects ${expectedArity} ` +
+        `argument${expectedArity === 1 ? "" : "s"}, ` +
+        `got ${actualArity}${pos}`
+      );
+    }
+
+    // Expand arguments in caller scope first
+    const expandedArgs = (filter.args || []).map((arg) =>
+      expandFilter(arg, patterns, stack, uniqueIdRef)
+    );
+
+    // Map internal variables and knots to unique fresh names
+    const varSubst = {};
+    const rootKnot = template.filter?.name;
+    if (rootKnot && !template.params.includes(rootKnot)) {
+      varSubst[rootKnot] =
+        filter.name || `_${rootKnot}_np${++uniqueIdRef.val}`;
+    }
+
+    function collectInternalVars(node) {
+      if (!node || typeof node !== "object") return;
+      if (node.name && !template.params.includes(node.name)) {
+        if (!varSubst[node.name]) {
+          varSubst[node.name] = `_${node.name}_np${++uniqueIdRef.val}`;
+        }
+      }
+      if (node.fields) {
+        for (const f of Object.values(node.fields)) {
+          collectInternalVars(f);
+        }
+      }
+      if (node.args) {
+        for (const a of node.args) {
+          collectInternalVars(a);
+        }
+      }
+    }
+    collectInternalVars(template.filter);
+
+    const nextStack = new Set(stack);
+    nextStack.add(patternName);
+
+    function substitute(node) {
+      if (!node || typeof node !== "object") return node;
+
+      if (node.type === "name") {
+        const paramIdx = template.params.indexOf(node.name);
+        if (paramIdx !== -1) {
+          const clonedArg = cloneFilter(expandedArgs[paramIdx]);
+          if (node.name && node.name !== template.params[paramIdx]) {
+            clonedArg.name = varSubst[node.name] || node.name;
+          }
+          return clonedArg;
+        } else {
+          const renamed = varSubst[node.name] || node.name;
+          return { ...node, name: renamed };
+        }
+      }
+
+      let knotName = undefined;
+      if (node.name) {
+        const paramIdx = template.params.indexOf(node.name);
+        if (paramIdx === -1) {
+          knotName = varSubst[node.name] || node.name;
+        } else {
+          knotName = node.name;
+        }
+      }
+
+      if (node.type === "union" || node.type === "product") {
+        const newFields = {};
+        for (const [key, fieldFilter] of Object.entries(
+          node.fields || {}
+        )) {
+          newFields[key] = substitute(fieldFilter);
+        }
+        const res = { ...node, fields: newFields };
+        if (knotName !== undefined) res.name = knotName;
+        else delete res.name;
+        return res;
+      }
+
+      if (node.type === "pattern_apply") {
+        const newArgs = (node.args || []).map(substitute);
+        const nestedApply = {
+          ...node,
+          args: newArgs,
+        };
+        if (knotName !== undefined) nestedApply.name = knotName;
+        else delete nestedApply.name;
+        return expandFilter(
+          nestedApply,
+          patterns,
+          nextStack,
+          uniqueIdRef
+        );
+      }
+
+      const res = { ...node };
+      if (knotName !== undefined) res.name = knotName;
+      else delete res.name;
+      return res;
+    }
+
+    const instantiated = substitute(template.filter);
+    if (filter.name) {
+      instantiated.name = filter.name;
+    }
+    return instantiated;
+  }
+
+  if (filter.type === "union" || filter.type === "product") {
+    const newFields = {};
+    for (const [key, fieldFilter] of Object.entries(
+      filter.fields || {}
+    )) {
+      newFields[key] = expandFilter(
+        fieldFilter,
+        patterns,
+        stack,
+        uniqueIdRef
+      );
+    }
+    return { ...filter, fields: newFields };
+  }
+
+  return cloneFilter(filter);
+}
+
+export function expandExp(
+  exp,
+  patterns = {},
+  stack = new Set(),
+  uniqueIdRef = { val: 0 }
+) {
+  if (!exp || typeof exp !== "object") return exp;
+
+  switch (exp.op) {
+    case "filter":
+      return {
+        ...exp,
+        filter: expandFilter(exp.filter, patterns, stack, uniqueIdRef),
+      };
+    case "pattern_apply":
+      return {
+        op: "filter",
+        filter: expandFilter(
+          { type: "pattern_apply", pattern: exp.pattern, args: exp.args },
+          patterns,
+          stack,
+          uniqueIdRef
+        ),
+        start: exp.start,
+        end: exp.end,
+      };
+    case "comp":
+      return {
+        ...exp,
+        comp: exp.comp.map((subExp) =>
+          expandExp(subExp, patterns, stack, uniqueIdRef)
+        ),
+      };
+    case "union":
+      return {
+        ...exp,
+        union: exp.union.map((subExp) =>
+          expandExp(subExp, patterns, stack, uniqueIdRef)
+        ),
+      };
+    case "product":
+      return {
+        ...exp,
+        product: exp.product.map(({ label, exp: subExp }) => ({
+          label,
+          exp: expandExp(subExp, patterns, stack, uniqueIdRef),
+        })),
+      };
+    default:
+      return exp;
+  }
+}
+
+export function expandPatternsInRels(rels, patterns = {}, options = {}) {
+  const allPatterns = { ...(options.patterns || {}), ...patterns };
+  if (options.libraries) {
+    for (const lib of options.libraries) {
+      const libPatterns =
+        lib.patterns ||
+        lib.defs?.patterns ||
+        lib.sourceDefs?.patterns ||
+        {};
+      for (const [name, pat] of Object.entries(libPatterns)) {
+        if (!(name in allPatterns)) {
+          allPatterns[name] = pat;
+        }
+      }
+    }
+  }
+
+  const uniqueIdRef = { val: 0 };
+  for (const relName of Object.keys(rels)) {
+    const rel = rels[relName];
+    if (rel?.def) {
+      rel.def = expandExp(rel.def, allPatterns, new Set(), uniqueIdRef);
+    }
+  }
+
+  return rels;
+}
+
+export default {
+  expandFilter,
+  expandExp,
+  expandPatternsInRels,
+};

package/object.mjs

@@ -489,6 +489,24 @@ function compileLibrary(script, options = {}) {
     Object.entries(meta).filter(([hash]) => libraryMetaHashes.has(hash))
   );
 
+  const libPatterns = {};
+  if (options.libraries) {
+    for (const lib of options.libraries) {
+      const lp =
+        lib.patterns ||
+        lib.defs?.patterns ||
+        lib.sourceDefs?.patterns ||
+        {};
+      Object.assign(libPatterns, lp);
+    }
+  }
+  if (options.patterns) {
+    Object.assign(libPatterns, options.patterns);
+  }
+  if (annotated.sourceDefs?.patterns) {
+    Object.assign(libPatterns, annotated.sourceDefs.patterns);
+  }
+
   return {
     format: "k-object",
     codes: allCodes,
@@ -496,6 +514,7 @@ function compileLibrary(script, options = {}) {
     relAlias: serialized.relAlias,
     compileStats: serialized.compileStats,
     meta: libMeta,
+    patterns: libPatterns,
     main: null
   };
 }
@@ -506,13 +525,22 @@ function hydrateObject(object) {
   }
   codes.load(object.codes);
   const hydratedRels = Object.fromEntries(
-    Object.entries(object.rels).map(([name, rel]) => [name, hydrateRelation(rel)])
+    Object.entries(object.rels).map(([name, rel]) => [
+      name,
+      hydrateRelation(rel)
+    ])
   );
-  return { ...object, rels: hydratedRels };
+  return {
+    ...object,
+    rels: hydratedRels,
+    patterns: object.patterns || {}
+  };
 }
 
 function loadLibrary(object) {
-  const hydrated = isHydratedObject(object) ? object : hydrateObject(object);
+  const hydrated = isHydratedObject(object)
+    ? object
+    : hydrateObject(object);
   if (hydrated.main != null) {
     throw new Error("Expected a library (main: null), got an executable");
   }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "7.2.0",
+    "version": "8.1.0",
     "description": "k — a language for content-addressable schemas and data transformations over algebraic data types (products and tagged unions); includes runtime, contract derivation, REPL, and codec toolchain",
     "publishConfig": {
         "access": "public"

package/parser.jison

@@ -49,9 +49,11 @@ function fromEscString(escString) {
 "<"                                            return 'LA';
 "{"                                            return 'LC';
 "("                                            return 'LP';
+"["                                            return 'LB';
 ">"                                            return 'RA';
 "}"                                            return 'RC';
 ")"                                            return 'RP';
+"]"                                            return 'RB';
 "="                                            return 'EQ'; 
 "..."                                          return 'DOTS';
 "."                                            return 'DOT';
@@ -71,7 +73,7 @@ function fromEscString(escString) {
 /lex
 
 %token NAME STRING
-%token LA LC LP RA RP RC EQ DOT COMMA SC COL AT QMARK DOTS DIV VID
+%token LA LC LP LB RA RC RP RB EQ DOT COMMA SC COL AT QMARK DOTS DIV VID
 %token INCREMENTAL
 %token EOF
 
@@ -85,9 +87,11 @@ at: AT                                  { $$ = getToken(yytext,yy,_$); };
 la: LA                                  { $$ = getToken(yytext,yy,_$); };
 lc: LC                                  { $$ = getToken(yytext,yy,_$); };
 lp: LP                                  { $$ = getToken(yytext,yy,_$); };
+lb: LB                                  { $$ = getToken(yytext,yy,_$); };
 ra: RA                                  { $$ = getToken(yytext,yy,_$); };
 rc: RC                                  { $$ = getToken(yytext,yy,_$); };
 rp: RP                                  { $$ = getToken(yytext,yy,_$); };
+rb: RB                                  { $$ = getToken(yytext,yy,_$); };
 eq: EQ                                  { $$ = getToken(yytext,yy,_$); };
 dots: DOTS                              { $$ = getToken(yytext,yy,_$); };
 dot: DOT                                { $$ = getToken(yytext,yy,_$); };
@@ -100,9 +104,14 @@ qmark: QMARK                            { $$ = getToken(yytext,yy,_$); };
 incremental: INCREMENTAL                { $$ = getToken(yytext,yy,_$); };
 
 input_with_eof: initialize_symbol_table defs comp EOF               {
-    const result = {defs: {rels: s.rels, codes: s.codes}, exp: $3};
-    // console.log(JSON.stringify(result, "", 2));
-    // process.exit(0);
+    const result = {
+        defs: {
+            rels: s.rels,
+            codes: s.codes,
+            patterns: s.patterns
+        },
+        exp: $3
+    };
     return result;
 };
 
@@ -113,17 +122,71 @@ initialize_symbol_table
 
 defs:                                   {  }
     | defs name eq comp sc              { s.add_rel($2.value,$4); }
+    | defs name lb pattern_params rb eq filter sc
+        {
+            const seen = new Set();
+            for (const p of $4) {
+                if (seen.has(p)) {
+                    const msg =
+                        `Duplicate parameter '${p}' ` +
+                        `in pattern '${$2.value}'.`;
+                    anError(@4, msg);
+                }
+                seen.add(p);
+            }
+            s.add_pattern($2.value, $4, $7);
+        }
+    ;
+
+pattern_params
+    : /* empty */                       { $$ = []; }
+    | non_empty_pattern_params          { $$ = $1; }
+    ;
+
+non_empty_pattern_params
+    : name                              { $$ = [$1.value]; }
+    | non_empty_pattern_params comma name
+                                        { $$ = [].concat($1, $3.value); }
     ;
 
 filter_
     : lp dots                 rp  { $$ = { type: null, open: true, fields: {}, start: $1.start, end: $3.end}; }
     | la labelled_filters      ra { $$ = { type: "union", open: $2.open, fields: $2.fields, start: $1.start, end: $3.end}; }
     | lc labelled_filters      rc { $$ = { type: "product", open: $2.open, fields: $2.fields, start: $1.start, end: $3.end}; }
+    | name lb pattern_args rb
+                                  {
+                                      $$ = {
+                                          type: "pattern_apply",
+                                          pattern: $1.value,
+                                          args: $3,
+                                          start: $1.start,
+                                          end: $4.end
+                                      };
+                                  }
+    ;
+
+pattern_args
+    : /* empty */                       { $$ = []; }
+    | non_empty_pattern_args            { $$ = $1; }
+    ;
+
+non_empty_pattern_args
+    : filter                            { $$ = [$1]; }
+    | non_empty_pattern_args comma filter
+                                        { $$ = [].concat($1, $3); }
     ;
 
 filter
     : filter_                      { $$ = $1; }
-    | filter_ EQ name              { $$ = { name: $3.value, ...$1, start: $1.start, end: $3.end }; }
+    | filter_ EQ name
+                                   {
+                                       $$ = {
+                                           ...$1,
+                                           name: $3.value,
+                                           start: $1.start,
+                                           end: $3.end
+                                       };
+                                   }
     | name                         { $$ = { type: 'name', name: $1.value, open: true, start: $1.start, end: $1.end}; }
     ;
 labelled_filters