@fraczak/k 5.1.2 → 6.0.0

package/run.mjs

@@ -1,269 +1,302 @@
 import assert from "assert";
-import { find } from "./codes.mjs";
+import { Product, Variant, edgeSubpattern, composePattern, withPattern } from "./Value.mjs"
+import { exportPatternGraph, intersectPropertyListPatterns } from "./codecs/runtime/codec.mjs";
+import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 
-const modulo = (a, b) => ((+a % (b = +b)) + b) % b;
-const valid = (x) => (isNaN(x) ? undefined : x);
+const builtin = {
+  "_log!": (arg) => {
+    console.error(`_log!: ${arg}`);
+
+    return arg;
+  }
+};
 
-function isOpen(x) {
-  return (Array.isArray(x) && x.open);
+const codes = { };
+const staticPatternCache = new WeakMap();
+const intersectionCache = new Map();
+const singletonCheckCache = new WeakMap();
+const patternPairCache = new WeakMap();
+const NULL_INTERSECTION = {};
+
+function staticPattern(typePatternGraph, exp, index) {
+  if (!typePatternGraph || !exp.patterns) return null;
+  return exportedPattern(typePatternGraph, exp.patterns[index]);
+}
+
+function outputPattern(typePatternGraph, exp) {
+  return staticPattern(typePatternGraph, exp, 1);
 }
 
-function isClosed(x) {
-  return (Array.isArray(x) && !x.open);
+function isSingletonPattern(pattern) {
+  if (singletonCheckCache.has(pattern)) return singletonCheckCache.get(pattern);
+  const result = pattern.every(([kind]) => kind === "closed-product" || kind === "closed-union");
+  singletonCheckCache.set(pattern, result);
+  return result;
 }
 
-Array.prototype.toJSON = function () {
-  if (this.open) {
-    // throw new Error(`Cannot serialize open vector: ${JSON.stringify([...this])}.`);
-    return {"OPEN VECTOR": [...this]};
+function intersectPatterns(left, right) {
+  if (!left || left.length === 0) return right;
+  if (!right || right.length === 0) return left;
+  if (left === right) return left;
+  if (left[0]?.[0] === "any") return right;
+  if (right[0]?.[0] === "any") return left;
+
+  const cached = patternPairCache.get(left)?.get(right);
+  if (cached !== undefined) return cached === NULL_INTERSECTION ? null : cached;
+
+  function cache(result) {
+    let rightMap = patternPairCache.get(left);
+    if (!rightMap) {
+      rightMap = new WeakMap();
+      patternPairCache.set(left, rightMap);
+    }
+    rightMap.set(right, result || NULL_INTERSECTION);
+    return result;
   }
-  return this;
-};
 
-function closeVector(val) {
-  if (isOpen(val)) {
-    return [...val];
+  if (isSingletonPattern(left) || isSingletonPattern(right)) {
+    try {
+      return cache(intersectPropertyListPatterns(left, right));
+    } catch {
+      return cache(null);
+    }
+  }
+
+  const leftKey = JSON.stringify(left);
+  const rightKey = JSON.stringify(right);
+  if (leftKey === rightKey) return left;
+
+  const key = `${leftKey}\n${rightKey}`;
+  if (intersectionCache.has(key)) return cache(intersectionCache.get(key));
+
+  try {
+    const pattern = intersectPropertyListPatterns(left, right);
+    intersectionCache.set(key, pattern);
+    return cache(pattern);
+  } catch {
+    intersectionCache.set(key, null);
+    return cache(null);
   }
-  console.error("Can close only an open vector.");
-  return val;
 }
 
-const builtin = {
-  "_log!": (arg) => {
-    console.error(`_log!: ${JSON.stringify(arg)}`);
-    return arg;
-  },
-  GT: (args) => {
-    const [last, ...rest] = args;
-    const [ok, _] = rest.reduce(
-      ([ok, last], x) => [ok && last > x, x],
-      [true, last]
+function exportedPattern(typePatternGraph, patternId) {
+  let graphCache = staticPatternCache.get(typePatternGraph);
+  if (!graphCache) {
+    graphCache = new Map();
+    staticPatternCache.set(typePatternGraph, graphCache);
+  }
+  patternId = typePatternGraph.find(patternId);
+  if (!graphCache.has(patternId)) {
+    graphCache.set(
+      patternId,
+      patternToPropertyList(exportPatternGraph(typePatternGraph, patternId))
     );
-    if (ok) return args;
-  },
-  EQ: (args) => {
-    const [first, ...rest] = args;
-    const ok = rest.reduce((ok, x) => ok && first === x, true);
-    if (ok) return args;
-  },
-  PLUS: (args) => valid(args.reduce((res, x) => res + x, 0)),
-  TIMES: (args) => valid(args.reduce((res, x) => res * x, 1)),
-  DIV: ([x, y]) => {
-    const div = Math.floor(x / y);
-    const rem = modulo(x, y);
-    if (x === div * y + rem) return { div, rem };
-  },
-  FDIV: ([x, y]) => x / y,
-  CONCAT: (strs) => strs.join(""),
-  toVEC: (str) => [...`${str}`],
-  true: () => true,
-  false: () => false,
-  null: () => null,
-  toJSON: (x) => JSON.stringify(x),
-  fromJSON: (x) => JSON.parse(x),
-  CONS: ({car, cdr}) => { try { return [car, ...cdr]; } catch (e) { return undefined; } },
-  SNOC: (x) => (x.length > 0 ? {car: x[0], cdr: x.slice(1)} : undefined),
-  toDateMsec: (x) => new Date(x).getTime(),
-  toDateStr: (x) => new Date(x).toISOString(),
-};
+  }
+  return graphCache.get(patternId);
+}
 
-const codes = {
-  "@int": (x) => Number.isInteger(x),
-  "@string": (x) => x instanceof String || "string" === typeof x,
-  "@bool": (x) => x === true || x === false,
-};
+function expLocation(exp) {
+  return exp.start ? ` (lines ${exp.start.line}:${exp.start.column}...${exp.end?.line}:${exp.end?.column})` : "";
+}
+
+function patternPreview(pattern) {
+  return JSON.stringify(pattern);
+}
+
+function constrainInput(value, typePatternGraph, exp) {
+  const constraint = staticPattern(typePatternGraph, exp, 0);
+  return constrainWithPattern(value, constraint, exp);
+}
+
+function constrainWithPattern(value, constraint, exp) {
+  if (!constraint) return value;
+  const pattern = intersectPatterns(constraint, value.pattern);
+  if (!pattern) {
+    throw new TypeError(
+      `Type Error in '${exp.op}'${expLocation(exp)}\n` +
+      ` - Value envelope does not intersect expression input pattern.\n` +
+      ` - input pattern: ${patternPreview(constraint)}\n` +
+      ` - value envelope: ${patternPreview(value.pattern)}`
+    );
+  }
+  return withPattern(value, pattern);
+}
+
+function compiledExp(findCode, exp, typePatternGraph) {
+  const cached = exp._compiledRun;
+  if (cached?.findCode === findCode && cached?.typePatternGraph === typePatternGraph && cached?.defs === run.defs) {
+    return cached.fn;
+  }
 
-function verify(code, value) {
+  const compiled = {
+    findCode,
+    typePatternGraph,
+    defs: run.defs,
+    target: null,
+    fn(value) {
+      return compiled.target(value);
+    }
+  };
+  exp._compiledRun = compiled;
+
+  const inputPattern = staticPattern(typePatternGraph, exp, 0);
+  const staticOutputPattern = outputPattern(typePatternGraph, exp);
+  const constrain = (value) => {
+    if (value === undefined) return undefined;
+    return constrainWithPattern(value, inputPattern, exp);
+  };
+  const defined = (value) => value;
+
+  let fn;
+  switch (exp.op) {
+    case "code":
+      fn = (value) => {
+        value = constrain(value);
+        if (value === undefined) return undefined;
+        return verify(findCode, exp.code, value) ? value : undefined;
+      };
+      break;
+    case "identity":
+      fn = defined;
+      break;
+    case "filter":
+      fn = constrain;
+      break;
+    case "ref":
+      {
+        const defn = run.defs.rels[exp.ref];
+        if (defn != undefined) {
+          const refFn = compiledExp(findCode, defn.def, defn.typePatternGraph);
+          fn = (value) => {
+            return value === undefined ? undefined : refFn(value);
+          };
+        } else {
+          const builtin_func = builtin[exp.ref];
+          if (builtin_func != null) {
+            fn = (value) => {
+              value = constrain(value);
+              return value === undefined ? undefined : builtin_func(value);
+            };
+          } else {
+            fn = () => {
+              throw(`Unknown ref: '${exp.ref}'`);
+            };
+          }
+        }
+      }
+      break;
+    case "dot":
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        return withPattern(value.product[exp.dot], staticOutputPattern || edgeSubpattern(value.pattern, exp.dot));
+      };
+      break;
+    case "div":
+      fn = (value) => {
+        if (value === undefined || value.tag !== exp.div) return undefined;
+        return withPattern(value.value, staticOutputPattern || edgeSubpattern(value.pattern, exp.div));
+      };
+      break;
+    case "comp": {
+      const parts = exp.comp.map((part) => compiledExp(findCode, part, typePatternGraph));
+      fn = (value) => {
+        value = constrain(value);
+        for (let i = 0, len = parts.length; i < len; i++) {
+          value = parts[i](value);
+          if (value === undefined) return undefined;
+        }
+        return value;
+      };
+      break;
+    }
+    case "union": {
+      const parts = exp.union.map((part) => compiledExp(findCode, part, typePatternGraph));
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        for (let i = 0, len = parts.length; i < len; i++) {
+          const result = parts[i](value);
+          if (result !== undefined) return result;
+        }
+        return undefined;
+      };
+      break;
+    }
+    case "product": {
+      const labels = exp.product.map(({ label }) => label);
+      const fieldFns = exp.product.map(({ exp: e }) => compiledExp(findCode, e, typePatternGraph));
+      if (staticOutputPattern) {
+        fn = (value) => {
+          if (value === undefined) return undefined;
+          const result = {};
+          for (let i = 0, len = labels.length; i < len; i++) {
+            const r = fieldFns[i](value);
+            if (r === undefined) return undefined;
+            result[labels[i]] = r;
+          }
+          return new Product(result, staticOutputPattern);
+        };
+      } else {
+        fn = (value) => {
+          if (value === undefined) return undefined;
+          const result = {};
+          const patternEntries = [];
+          for (let i = 0, len = labels.length; i < len; i++) {
+            const r = fieldFns[i](value);
+            if (r === undefined) return undefined;
+            const label = labels[i];
+            result[label] = r;
+            patternEntries.push([label, r.pattern]);
+          }
+          return new Product(result, composePattern("closed-product", patternEntries));
+        };
+      }
+      break;
+    }
+    case "vid":
+      fn = (value) => {
+        if (value === undefined) return undefined;
+        return new Variant(exp.vid, value, composePattern("open-union", [[exp.vid, value.pattern]]));
+      };
+      break;
+    default:
+      assert(false,`Unknown operation: '${exp.op}'`);
+  }
+
+  compiled.target = fn;
+  return compiled.fn;
+}
+
+function verify(findCode, code, value) {
   "use strict";
   if (code == null) return false;
-  code = find(code);
+  code = findCode(code);
   switch (code.code) {
-    case "vector":
-      if (!Array.isArray(value)) return false;
-      return value.every((x) => verify(code.vector, x));
     case "product":
-      if ("object" !== typeof value) return false;
+      if (! (value instanceof Product)) return false;
       else {
-        const fields = Object.keys(value);
+        const fields = Object.keys(value.product);
         if (fields.length !== Object.keys(code.product).length) return false;
         return fields.every((label) =>
-          verify(code.product[label], value[label])
+          verify(findCode, code.product[label], value.product[label])
         );
       }
     case "union":
-      if ("object" !== typeof value) return false;
+      if (! (value instanceof Product)) return false;
       else {
-        const fields = Object.keys(value);
+        const fields = Object.keys(value.product);
         if (fields.length !== 1) return false;
-        return verify(code.union[fields[0]], value[fields[0]]);
+        return verify(findCode, code.union[fields[0]], value.product[fields[0]]);
       }
     default: 
       return codes[code.code](value);
   }
 }
 
-function run(exp, value) {
-  "use strict";
-  if (value === undefined) return;
-  while (true) {
-    if (isOpen(value)) {
-      if (exp.op === "caret2") return [...value];
-      const result = [];
-      result.open = true
-      for (const v of value) {
-        const r = run(exp, v);
-        if (r !== undefined) result.push(r);
-      }
-      return result;
-    }
-    switch (exp.op) {
-      case "code":
-        if (verify(exp.code, value)) {
-          return value;
-        }
-        return;
-      case "identity":
-        return value;
-      case "str":
-      case "int":
-        return exp[exp.op];
-      case "ref": {
-        const defn = run.defs.rels[exp.ref];
-        if (defn != undefined) {
-          exp = defn.def;
-          continue;
-        }
-        const builtin_func = builtin[exp.ref];
-        if (builtin_func != null) {
-          return builtin_func(value);
-        }
-        throw(`Unknown ref: '${exp.ref}'`);
-      }
-      case "dot":
-        // a hack to allow something like 'null . null' or '0 . 0' to work by returning unit
-        if (value === null || typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-          if (`${value}` === `${exp.dot}`) return {};
-          return;
-        }
-        return value[exp.dot];
-      case "pipe": {
-        assert(isClosed(value), `PIPE (|): Only a regular vector value can be "open".`);
-        const result = [...value];
-        result.open = true;
-        return result;
-      }
-      case "comp":
-        for (let i = 0, len = exp.comp.length - 1; i < len; i++) {
-          const result = run(exp.comp[i], value);
-          if (result === undefined) return;
-          value = result;
-        }
-        exp = exp.comp[exp.comp.length - 1];
-        continue;
-      case "union":
-        if (exp.union.length === 0) return;
-        for (let i = 0, len = exp.union.length -1; i < len; i++) {
-          const result = run(exp.union[i], value);
-          if (result !== undefined) {
-            return result;
-          }
-        }
-        exp = exp.union[exp.union.length - 1];
-        continue;
-      case "vector": {
-        let result = [];
-        let open = false;
-        for (let i = 0, len = exp.vector.length; i < len; i++) {
-          const r = run(exp.vector[i], value);
-          if (r === undefined) return;
-          if (open) {
-            if (isOpen(r)) {
-              const newResult = [];
-              newResult.open = true;
-              for (const x of result) {
-                for (const y of r) {
-                  newResult.push([...x, y]);
-                }
-              }
-              result = newResult;
-            } else {
-              for (const x of result) x.push(r);
-            }
-          } else {
-            if (isOpen(r)) {
-              open = true;
-              const newResult = [];
-              newResult.open = true;
-              for (const x of r) {
-                newResult.push([...result, x]);
-              } 
-              result = newResult;
-            } else {
-              result.push(r);
-            }
-          }
-        }
-        return result;
-      }
-      case "product": {
-        let result = {};
-        let open = false;
-        for (let i = 0, len = exp.product.length; i < len; i++) {
-          const { label, exp: e } = exp.product[i];
-          const r = run(e, value);
-          if (r === undefined) return;
-          if (open) {
-            if (isOpen(r)) {
-              let newResult = [];
-              newResult.open = true;
-              for (const v of r) {
-                for (const x of result) {
-                  newResult.push({...x, [label]: v});
-                }
-              }
-              result = newResult;
-            } else {
-              let newResult = [];
-              newResult.open = true;
-              for (const x of result) {
-                newResult.push({...x, [label]: r});
-              }
-              result = newResult;
-            } 
-          } else {
-            if (isOpen(r)) {
-              open = true;
-              let newResult = [];
-              newResult.open = true;
-              for (const v of r.values()) {
-                newResult.push({...result, [label]: v});
-              }
-              result = newResult;
-            } else {
-              result[label] = r;
-            }
-          }      
-        }
-        return result
-      }
-      case "caret": {
-        const result = run(exp.caret, value);
-        // assert(isOpen(result), "CARET (^): Only an 'open' vector can be closed.");
-        if (! isOpen(result))
-          throw new Error(`Type Error (line: ${exp.end?.line}:${exp.end?.column}): CARET (^): Only 'unboxed' values can be 'boxed'.`)
-        return [...result];
-      }  
-      case "filter": {
-        return value;
-      }
-      default:
-        assert(false,`Unknown operation: '${exp.op}'`);
-    
-    }
-  };
+function run(findCode, exp, value, typePatternGraph) {
+  return compiledExp(findCode, exp, typePatternGraph || null)(value);
 }
 
 run.builtin = builtin;
 
 export default run;
-export { run , closeVector };
+export { run  };

package/symbol-table.mjs

@@ -9,19 +9,9 @@ function is_identity_rel(rel) {
 }
 
 function is_constant_rel(rel) {
-  switch (rel.op) {
-    case "int":
-    case "str":
-      return true;
-    case "vector":
-      return Object.values(rel[rel.op]).every(is_constant_rel);
-    case "product":
-      return Object.values(rel[rel.op]).every(({ exp }) =>
-        is_constant_rel(exp)
-      );
-    default:
-      return false;
-  }
+  if (rel.op == "product")
+    return Object.values(rel[rel.op]).every(({ exp }) => is_constant_rel(exp));
+  return false;
 }
 
 function is_empty_rel(rel) {
@@ -31,14 +21,10 @@ function is_empty_rel(rel) {
 function is_full_rel(rel) {
   if (is_constant_rel(rel)) return true;
   switch (rel.op) {
-    case "int":
-    case "str":
     case "identity":
       return true;
     case "comp":
       return rel.comp.every(is_full_rel);
-    case "vector":
-      return Object.values(rel[rel.op]).every(is_full_rel);
     case "product":
       return Object.values(rel[rel.op]).every(({ exp }) =>
         is_full_rel(exp)

package/test-fingerprint.mjs

@@ -3,18 +3,18 @@ import { encodeCodeToString, find } from './codes.mjs';
 import hash from './hash.mjs';
 [
     `
+    $bits = < bits 0,  bits 1, {} _ >;
     $nat = < {} zero, nat succ>;
     $pair = {nat x, nat y};
-    $b = {@int"x", @bool y};
-    $vector = [@int];
-    $tree = <{nat value, tree left, tree right} binary, nat leaf, {nat value, tree tree} unary, [tree] list_of_trees>;
+    $b = { bits"x", bits y};
+    $tree = < {nat value, tree left, tree right} binary, nat leaf, {nat value, tree tree} unary >;
   
-    succ = { $nat succ} $nat;
+    succ =  | succ $nat;
     plus = $pair <
-      {.x.zero stop, .y result} .result,
-      {.x.succ x, .y succ y } plus
+      {.x/zero stop, .y result} .result,
+      {.x/succ x, .y succ y } plus
     > $nat;
-  {{} zero} succ succ {() x, () y} plus
+  {}|zero succ succ {() x, () y} plus
     `     
   ].map(function (script) {
     console.log("test-fingerprint:");