@bramas/simulant-lang 0.0.0-stage → 0.1.1

package/src/resolve.ts

@@ -0,0 +1,35 @@
+/**
+ * Replaces the literals of type `infer` (`.ctor`, `none`, `[]` from the front
+ * end) by literals of the types the checker found, and folds lists of
+ * literals into a single literal. The result is plain IR: the interpreter
+ * and the Lean generator never see `infer`.
+ */
+import type { Experiment, Expr, Json, Type } from './ir';
+import { T } from './types';
+
+export function resolveTypes(exp: Experiment, resolutions: Map<Expr, Type>, onCopy?: (from: Expr, to: Expr) => void): Experiment {
+  const copy = (x: unknown): unknown => {
+    if (!x || typeof x !== 'object') return x;
+    if (Array.isArray(x)) return x.map(copy);
+    const o = x as Record<string, unknown>;
+    if (typeof o.e === 'string') {
+      const e = o as Expr;
+      let out: Expr;
+      if (e.e === 'lit' && e.type.k === 'infer') {
+        const t = resolutions.get(e);
+        if (!t) throw new Error(`a literal was not resolved: ${JSON.stringify(e.value)}`);
+        out = { e: 'lit', type: t, value: e.value };
+      } else {
+        out = Object.fromEntries(Object.entries(o).map(([k, v]) => [k, copy(v)])) as Expr;
+        if (out.e === 'call' && out.fn === 'list' && out.args.every(a => a.e === 'lit')) {
+          const items = out.args as Extract<Expr, { e: 'lit' }>[];
+          out = { e: 'lit', type: T.list(items[0].type), value: items.map(a => a.value) as Json[] };
+        }
+      }
+      onCopy?.(e, out);
+      return out;
+    }
+    return Object.fromEntries(Object.entries(o).map(([k, v]) => [k, copy(v)]));
+  };
+  return copy(exp) as Experiment;
+}

package/src/standalone.ts

@@ -0,0 +1,47 @@
+/**
+ * Checks and resolves a component on its own, in the smallest experiment
+ * that contains it. The Lean library is generated from components resolved
+ * this way, independently of any model.
+ */
+import { check } from './check';
+import type { Component, Experiment, Expr, Param, Type } from './ir';
+import { IR_VERSION } from './ir';
+import { resolveTypes } from './resolve';
+import { T } from './types';
+
+/** Experiment parameters read by the component's initial values (`site := param site`), with their types. */
+function inputs(c: Component): Param[] {
+  const found = new Map<string, Type>();
+  const fields = [...(c.world ?? []), ...(c.agent ?? [])];
+  for (const f of fields) {
+    const init = c.init?.world?.[f.name] ?? c.init?.agent?.[f.name];
+    if (init?.e === 'param') found.set(init.name, f.type);
+  }
+  return [...found].map(([name, type]) => ({ name, type }));
+}
+
+export function standaloneExperiment(c: Component): Experiment {
+  const lit = (type: Type, value: unknown): Expr => ({ e: 'lit', type, value } as Expr);
+  return {
+    irVersion: IR_VERSION,
+    name: `${c.name} alone`,
+    model: {
+      name: c.name, topology: { kind: 'ring', size: { e: 'param', name: 'N' } }, sensors: [], memory: 'persistent',
+      frame: { kind: 'common' }, round: 'fsync', movement: 'rigid', components: [c], symmetries: 'derived',
+    },
+    algorithm: {
+      name: 'idle', uses: [], pub: T.unit, mem: T.unit, init: { pub: lit(T.unit, null), mem: lit(T.unit, null) },
+      step: { e: 'record', fields: { move: lit(T.move, 'stay'), pub: { e: 'var', name: 'pub' }, mem: { e: 'var', name: 'mem' } } },
+    },
+    task: { name: 'none', goal: 'safety', verdict: lit(T.verdict, 'inProgress') },
+    params: [{ name: 'N', type: T.nat }, ...inputs(c)],
+    agents: { count: lit(T.nat, 1), pos: lit(T.node, 0) },
+  };
+}
+
+export function resolveComponent(c: Component): Component {
+  const exp = standaloneExperiment(c);
+  const checked = check(exp);
+  if (checked.errors.length) throw new Error(`${c.name}:\n${checked.errors.join('\n')}`);
+  return resolveTypes(exp, checked.resolutions).model.components[0];
+}

package/src/types.ts

@@ -0,0 +1,109 @@
+import type { Field, Type } from './ir';
+
+export const T = {
+  unit: { k: 'unit' } as Type,
+  bool: { k: 'bool' } as Type,
+  nat: { k: 'nat' } as Type,
+  int: { k: 'int' } as Type,
+  string: { k: 'string' } as Type,
+  node: { k: 'node' } as Type,
+  move: { k: 'move' } as Type,
+  frame: { k: 'frame' } as Type,
+  agent: { k: 'agent' } as Type,
+  config: { k: 'config' } as Type,
+  effect: { k: 'effect' } as Type,
+  decision: { k: 'decision' } as Type,
+  verdict: { k: 'verdict' } as Type,
+  pub: { k: 'pub' } as Type,
+  infer: { k: 'infer' } as Type,
+  enum: (name: string, ctors: string[]): Type => ({ k: 'enum', name, ctors }),
+  option: (of: Type): Type => ({ k: 'option', of }),
+  record: (fields: Record<string, Type> | Field[]): Type =>
+    ({ k: 'record', fields: Array.isArray(fields) ? fields : Object.entries(fields).map(([name, type]) => ({ name, type })) }),
+  list: (of: Type): Type => ({ k: 'list', of }),
+  multiset: (of: Type): Type => ({ k: 'multiset', of }),
+  fn: (params: Type[], ret: Type): Type => ({ k: 'fn', params, ret }),
+};
+
+export const MOVES = ['stay', 'cw', 'ccw'] as const;
+export const VERDICTS = ['success', 'failure', 'inProgress'] as const;
+
+export function typeEq(a: Type, b: Type): boolean {
+  if (a.k !== b.k) return false;
+  switch (a.k) {
+    case 'enum': {
+      const o = b as typeof a;
+      return a.name === o.name && a.ctors.length === o.ctors.length && a.ctors.every((c, i) => c === o.ctors[i]);
+    }
+    case 'option': case 'list': case 'multiset':
+      return typeEq(a.of, (b as typeof a).of);
+    case 'record': {
+      const o = b as typeof a;
+      // Fields are matched by name, as in Lean structure instances.
+      return a.fields.length === o.fields.length
+        && a.fields.every(f => o.fields.some(g => g.name === f.name && typeEq(f.type, g.type)));
+    }
+    case 'fn': {
+      const o = b as typeof a;
+      return a.params.length === o.params.length && a.params.every((p, i) => typeEq(p, o.params[i])) && typeEq(a.ret, o.ret);
+    }
+    default:
+      return true;
+  }
+}
+
+export function showType(t: Type): string {
+  switch (t.k) {
+    case 'enum': return t.name;
+    case 'option': return `Option ${wrap(t.of)}`;
+    case 'list': return `List ${wrap(t.of)}`;
+    case 'multiset': return `Multiset ${wrap(t.of)}`;
+    case 'record': return `{ ${t.fields.map(f => `${f.name} : ${showType(f.type)}`).join(', ')} }`;
+    case 'fn': return `(${t.params.map(showType).join(' → ')} → ${showType(t.ret)})`;
+    default: return t.k[0].toUpperCase() + t.k.slice(1);
+  }
+}
+
+function wrap(t: Type) {
+  const s = showType(t);
+  return /\s/.test(s) && !s.startsWith('{') ? `(${s})` : s;
+}
+
+/** Types whose values can be compared, stored in configurations and encoded. */
+export function isData(t: Type): boolean {
+  switch (t.k) {
+    case 'fn': case 'config': case 'effect': case 'decision': return false;
+    case 'option': case 'list': case 'multiset': return isData(t.of);
+    case 'record': return t.fields.every(f => isData(f.type));
+    default: return true;
+  }
+}
+
+/** Data that can be kept in a configuration: agents are only references within a round. */
+export function isStorable(t: Type): boolean {
+  switch (t.k) {
+    case 'agent': return false;
+    case 'option': case 'list': case 'multiset': return isStorable(t.of);
+    case 'record': return t.fields.every(f => isStorable(f.type));
+    default: return isData(t);
+  }
+}
+
+export function isCollection(t: Type): t is { k: 'list' | 'multiset'; of: Type } {
+  return t.k === 'list' || t.k === 'multiset';
+}
+
+export function fieldType(t: Type, name: string): Type | undefined {
+  return t.k === 'record' ? t.fields.find(f => f.name === name)?.type : undefined;
+}
+
+/** Replaces the `pub` placeholder by the public state of the composition. */
+export function resolvePub(t: Type, pub: Type): Type {
+  switch (t.k) {
+    case 'pub': return pub;
+    case 'option': case 'list': case 'multiset': return { k: t.k, of: resolvePub(t.of, pub) } as Type;
+    case 'record': return { k: 'record', fields: t.fields.map(f => ({ name: f.name, type: resolvePub(f.type, pub) })) };
+    case 'fn': return { k: 'fn', params: t.params.map(p => resolvePub(p, pub)), ret: resolvePub(t.ret, pub) };
+    default: return t;
+  }
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.