@bramas/simulant-lang 0.0.0-stage → 0.1.1

package/dist/builder.js

@@ -0,0 +1,221 @@
+import { IR_VERSION } from "./ir.js";
+import { T } from "./types.js";
+/** Nesting depth of lambdas under construction: parameter names depend only on it, so the IR is reproducible. */
+let depth = 0;
+export function ir(x) {
+    if (typeof x === 'boolean')
+        return { e: 'lit', type: T.bool, value: x };
+    if (typeof x === 'number') {
+        if (!Number.isInteger(x))
+            throw new Error(`not an integer: ${x}`);
+        return { e: 'lit', type: x < 0 ? T.int : T.nat, value: x };
+    }
+    return x.ir;
+}
+const call = (fn, ...args) => wrap({ e: 'call', fn, args: args.map(ir) });
+/** A lambda; parameter types are inferred by the checker. */
+function lambda(arity, f) {
+    const params = Array.from({ length: arity }, (_, i) => ({ name: arity === 1 ? `x${depth}` : `x${depth}_${i}` }));
+    depth++;
+    try {
+        return { e: 'fn', params, body: ir(f(...params.map(p => v(p.name)))) };
+    }
+    finally {
+        depth--;
+    }
+}
+const methods = {
+    not: self => ({ e: 'call', fn: 'not', args: [self] }),
+    and: (self, ...xs) => ({ e: 'call', fn: 'and', args: [self, ...xs.map(ir)] }),
+    or: (self, ...xs) => ({ e: 'call', fn: 'or', args: [self, ...xs.map(ir)] }),
+    length: self => ({ e: 'call', fn: 'length', args: [self] }),
+    isEmpty: self => ({ e: 'call', fn: 'isEmpty', args: [self] }),
+    isSome: self => ({ e: 'call', fn: 'isSome', args: [self] }),
+    isNone: self => ({ e: 'call', fn: 'isNone', args: [self] }),
+    sum: self => ({ e: 'call', fn: 'sum', args: [self] }),
+    toMultiset: self => ({ e: 'call', fn: 'toMultiset', args: [self] }),
+    toList: self => ({ e: 'call', fn: 'toList', args: [self] }),
+    dedup: self => ({ e: 'call', fn: 'dedup', args: [self] }),
+    has: (self, x) => ({ e: 'call', fn: 'mem', args: [ir(x), self] }),
+    with: (self, fields) => ({ e: 'with', on: self, fields: mapValues(fields, ir) }),
+};
+for (const fn of ['implies', 'eq', 'ne', 'lt', 'le', 'gt', 'ge', 'add', 'sub', 'mul', 'div', 'mod', 'getD', 'at', 'append', 'diff']) {
+    methods[fn] = (self, x) => ({ e: 'call', fn, args: [self, ir(x)] });
+}
+for (const fn of ['filter', 'map', 'any', 'all', 'count']) {
+    methods[fn] = (self, f) => ({ e: 'call', fn, args: [self, lambda(1, f)] });
+}
+export function wrap(expr) {
+    return new Proxy({ ir: expr }, {
+        get(target, prop) {
+            if (prop === 'ir')
+                return expr;
+            if (typeof prop !== 'string')
+                return target[prop];
+            const m = methods[prop];
+            if (m)
+                return (...args) => wrap(m(expr, ...args));
+            return wrap({ e: 'get', on: expr, field: prop });
+        },
+    });
+}
+function mapValues(o, f) {
+    return Object.fromEntries(Object.entries(o).map(([k, a]) => [k, f(a)]));
+}
+// ---------------------------------------------------------------------------
+// Expressions
+export const v = (name) => wrap({ e: 'var', name });
+export const lit = (type, value) => wrap({ e: 'lit', type, value });
+export const nat = (n) => lit(T.nat, n);
+export const int = (n) => lit(T.int, n);
+export const str = (s) => lit(T.string, s);
+export const move = (m) => lit(T.move, m);
+export const verdict = (s) => lit(T.verdict, s);
+export const ctor = (type, name) => lit(type, name);
+export const none = (of) => lit(T.option(of), null);
+export const unit = () => lit(T.unit, null);
+export const emptyList = (of) => lit(T.list(of), []);
+export const some = (x) => call('some', x);
+export const param = (name) => wrap({ e: 'param', name });
+export const not = (x) => call('not', x);
+export const and = (...xs) => call('and', ...xs);
+export const or = (...xs) => call('or', ...xs);
+export const min = (a, b) => call('min', a, b);
+export const max = (a, b) => call('max', a, b);
+export function ite(cond, then, otherwise) {
+    return wrap({ e: 'if', cond: ir(cond), then: ir(then), else: ir(otherwise) });
+}
+export function match(on, cases, otherwise) {
+    return wrap({ e: 'match', on: ir(on), cases: mapValues(cases, ir), ...(otherwise === undefined ? {} : { else: ir(otherwise) }) });
+}
+/** `let name := value; body`. */
+export function let_(name, value, body) {
+    return wrap({ e: 'let', name, value: ir(value), body: ir(body(v(name))) });
+}
+export function rec(fields) {
+    return wrap({ e: 'record', fields: mapValues(fields, ir) });
+}
+/** An adversary choice; `site` names it in witnesses. */
+export function choose(site, from, opts = {}) {
+    return wrap({
+        e: 'choose', site, from: ir(from),
+        ...(opts.such ? { such: lambda(1, opts.such) } : {}),
+        ...(opts.label ? { label: lambda(1, opts.label) } : {}),
+    });
+}
+/** A hook's result: raise a flag on a collection of agents, or on those satisfying a predicate. */
+export function effect(e = {}) {
+    return wrap({
+        e: 'effect',
+        ...(e.world ? { world: mapValues(e.world, ir) } : {}),
+        ...(e.raise ? { raise: mapValues(e.raise, r => typeof r === 'function' ? lambda(1, r) : ir(r)) } : {}),
+    });
+}
+export const nothing = () => effect();
+/** A call to a definition of the model or of the piece. */
+export const callDef = (name, ...args) => call(name, ...args);
+// Builtins that are not methods
+export const agents = (C) => call('agents', C);
+export const nodes = (C) => call('nodes', C);
+export const size = (C) => call('size', C);
+export const correct = (a) => call('correct', a);
+export const present = (a) => call('present', a);
+export const decisionOf = (a) => call('decisionOf', a);
+export const target = (n, m) => call('target', n, m);
+export const edgePresent = (n, m) => call('edgePresent', n, m);
+export const offset = (n, frame, i) => call('offset', n, frame, i);
+export const toGlobal = (frame, m) => call('toGlobal', frame, m);
+export const opposite = (m) => call('opposite', m);
+export const frames = () => call('frames');
+export const node = (n) => call('node', n);
+export const range = (n) => call('range', n);
+export const subsets = (l) => call('subsets', l);
+export const subsetsUpTo = (l, k) => call('subsetsUpTo', l, k);
+export const ofFn = (n, f) => wrap({ e: 'call', fn: 'ofFn', args: [ir(n), lambda(1, f)] });
+export const show = (x) => call('show', x);
+export const concat = (...xs) => call('concat', ...xs.map(x => typeof x === 'string' ? str(x) : x));
+// ---------------------------------------------------------------------------
+// Pieces
+const fields = (o) => o && Object.entries(o).map(([name, type]) => ({ name, type }));
+export function flag(name, visibility, acts) {
+    return { name, visibility, acts };
+}
+/** A sensor: `C`, `me` and `frame` are in scope. */
+export function sensor(name, type, body, equivariance) {
+    return { name, type, body: ir(body({ C: v('C'), me: v('me'), frame: v('frame') })), ...(equivariance ? { equivariance } : {}) };
+}
+export function def(name, params, ret, body) {
+    const ps = fields(params);
+    return { name, params: ps, ret, body: ir(body(Object.fromEntries(ps.map(p => [p.name, v(p.name)])))) };
+}
+export function component(spec) {
+    const p = Object.fromEntries(Object.keys(spec.params ?? {}).map(name => [name, v(name)]));
+    const hook = (h) => h && ir(h(v('C'), p));
+    const c = {
+        name: spec.name,
+        params: fields(spec.params),
+        args: spec.args,
+        world: fields(spec.world),
+        agent: fields(spec.agent),
+        flags: spec.flags,
+        sensors: spec.sensors,
+        actions: spec.actions,
+        init: spec.init && dropUndefined({
+            world: spec.init.world && mapValues(spec.init.world, x => ir(typeof x === 'function' ? x(p) : x)),
+            agent: spec.init.agent && mapValues(spec.init.agent, f => ir(f(v('i'), p))),
+        }),
+        beforeLook: hook(spec.beforeLook),
+        beforeMove: hook(spec.beforeMove),
+        afterMove: hook(spec.afterMove),
+        defs: spec.defs,
+        equivariance: spec.equivariance,
+    };
+    return dropUndefined(c);
+}
+export function model(spec) {
+    return dropUndefined({
+        name: spec.name,
+        topology: spec.topology,
+        sensors: spec.sensors,
+        memory: spec.memory ?? 'persistent',
+        frame: spec.frame ?? { kind: 'common' },
+        round: spec.round ?? 'fsync',
+        movement: 'rigid',
+        components: spec.components ?? [],
+        symmetries: spec.symmetries ?? 'derived',
+        defs: spec.defs,
+    });
+}
+export const ring = (size) => ({ kind: 'ring', size: ir(size) });
+export const dynamicRing = (size, k = 1) => ({ kind: 'dynamicRing', size: ir(size), k });
+export function algorithm(spec) {
+    const mem = spec.mem ?? T.unit;
+    const s = { mem: v('mem'), pub: v('pub'), view: v('view') };
+    const step = spec.step ? spec.step(s) : { move: move('stay') };
+    return dropUndefined({
+        name: spec.name,
+        uses: spec.uses,
+        pub: spec.pub,
+        mem,
+        init: { pub: ir(spec.init.pub(v('i'))), mem: ir(spec.init.mem ? spec.init.mem(v('i')) : unit()) },
+        step: rec({ pub: s.pub, mem: s.mem, ...step }).ir,
+        line: spec.line && ir(spec.line(v('mem'))),
+        native: spec.native,
+        defs: spec.defs,
+    });
+}
+export function task(spec) {
+    return dropUndefined({ name: spec.name, goal: spec.goal, verdict: ir(spec.verdict(v('C'))), equivariance: spec.equivariance, defs: spec.defs });
+}
+export function experiment(spec) {
+    const params = (spec.params ?? []).map(p => dropUndefined({ name: p.name, type: p.type, domain: p.domain === undefined ? undefined : ir(p.domain) }));
+    return dropUndefined({
+        irVersion: IR_VERSION, name: spec.name, model: spec.model, algorithm: spec.algorithm, task: spec.task, params,
+        agents: { count: ir(spec.agents.count), pos: ir(spec.agents.pos(v('i'))) },
+        limits: spec.limits,
+    });
+}
+/** Keeps the IR free of `undefined`, so that it round-trips through JSON unchanged. */
+function dropUndefined(o) {
+    return Object.fromEntries(Object.entries(o).filter(([, x]) => x !== undefined));
+}

package/dist/builtins.js

@@ -0,0 +1,156 @@
+import { isCollection, isData, showType, T, typeEq } from "./types.js";
+const err = (msg) => msg;
+function mentionsAgent(t) {
+    switch (t.k) {
+        case 'agent': return true;
+        case 'option':
+        case 'list':
+        case 'multiset': return mentionsAgent(t.of);
+        case 'record': return t.fields.some(f => mentionsAgent(f.type));
+        default: return false;
+    }
+}
+function same(name) {
+    return ([a, b]) => typeEq(a, b) ? (isData(a) ? T.bool : err(`${name}: cannot compare ${showType(a)}`))
+        : err(`${name}: ${showType(a)} and ${showType(b)} differ`);
+}
+function numeric(name, ret) {
+    return (args) => {
+        const t = args[0];
+        if (t.k !== 'nat' && t.k !== 'int')
+            return err(`${name}: expected Nat or Int, got ${showType(t)}`);
+        if (!args.every(a => typeEq(a, t)))
+            return err(`${name}: arguments must have the same type`);
+        return ret ?? t;
+    };
+}
+/** Numbers, or lists of Bool or Nat in lexicographic order (`false < true`, a prefix first), as in Lean. */
+function ordered(name) {
+    return (args) => {
+        const [a, b] = args;
+        if (a.k === 'list' && (a.of.k === 'bool' || a.of.k === 'nat')) {
+            return typeEq(a, b) ? T.bool : err(`${name}: ${showType(a)} and ${showType(b)} differ`);
+        }
+        return numeric(name, T.bool)(args);
+    };
+}
+function bools(name) {
+    return (args) => args.every(a => a.k === 'bool') ? T.bool : err(`${name}: expected Bool arguments`);
+}
+function collection(name, t) {
+    return isCollection(t) ? undefined : err(`${name}: expected a List or Multiset, got ${showType(t)}`);
+}
+const elem = (name) => ([l]) => collection(name, l) ?? [l.of];
+function predicate(name, ret) {
+    return {
+        arity: 2,
+        lambdas: { 1: elem(name) },
+        ret: ([l, f]) => collection(name, l)
+            ?? (f.k === 'fn' && f.ret.k === 'bool' ? ret(l) : err(`${name}: expected a predicate`)),
+    };
+}
+const CONFIG_CONTEXTS = ['init', 'sensor', 'hook', 'beforeMove', 'task', 'def'];
+export const BUILTINS = {
+    // Logic and comparison
+    not: { arity: 1, ret: bools('not') },
+    and: { ret: bools('and') },
+    or: { ret: bools('or') },
+    implies: { arity: 2, ret: bools('implies') },
+    eq: { arity: 2, ret: same('eq') },
+    ne: { arity: 2, ret: same('ne') },
+    lt: { arity: 2, ret: ordered('lt') },
+    le: { arity: 2, ret: ordered('le') },
+    gt: { arity: 2, ret: ordered('gt') },
+    ge: { arity: 2, ret: ordered('ge') },
+    // Arithmetic, following Lean: subtraction and division on Nat are truncated.
+    add: { arity: 2, ret: numeric('add') },
+    sub: { arity: 2, ret: numeric('sub') },
+    mul: { arity: 2, ret: numeric('mul') },
+    div: { arity: 2, ret: numeric('div') },
+    mod: { arity: 2, ret: numeric('mod') },
+    min: { arity: 2, ret: numeric('min') },
+    max: { arity: 2, ret: numeric('max') },
+    toInt: { arity: 1, ret: ([a]) => a.k === 'nat' ? T.int : err('toInt: expected Nat') },
+    // Options
+    some: { arity: 1, ret: ([a]) => T.option(a) },
+    isSome: { arity: 1, ret: ([o]) => o.k === 'option' ? T.bool : err('isSome: expected an Option') },
+    isNone: { arity: 1, ret: ([o]) => o.k === 'option' ? T.bool : err('isNone: expected an Option') },
+    getD: {
+        arity: 2,
+        ret: ([o, d]) => o.k === 'option' && typeEq(o.of, d) ? d : err('getD: expected an Option and a default of its type'),
+    },
+    // Collections (List and Multiset)
+    length: { arity: 1, ret: ([l]) => collection('length', l) ?? T.nat },
+    isEmpty: { arity: 1, ret: ([l]) => collection('isEmpty', l) ?? T.bool },
+    filter: predicate('filter', l => l),
+    any: predicate('any', () => T.bool),
+    all: predicate('all', () => T.bool),
+    count: predicate('count', () => T.nat),
+    map: {
+        arity: 2,
+        lambdas: { 1: elem('map') },
+        ret: ([l, f]) => collection('map', l) ?? (f.k === 'fn' ? { k: l.k, of: f.ret } : err('map: expected a function')),
+    },
+    sum: { arity: 1, ret: ([l]) => isCollection(l) && l.of.k === 'nat' ? T.nat : err('sum: expected a collection of Nat') },
+    mem: { arity: 2, ret: ([x, l]) => collection('mem', l) ?? (typeEq(x, l.of) ? T.bool : err('mem: element type differs')) },
+    range: { arity: 1, ret: ([n]) => n.k === 'nat' ? T.list(T.nat) : err('range: expected Nat') },
+    toMultiset: { arity: 1, ret: ([l]) => l.k === 'list' ? T.multiset(l.of) : err('toMultiset: expected a List') },
+    /** The elements in canonical order; not for agents, which have no order. */
+    toList: { arity: 1, ret: ([l]) => l.k !== 'multiset' ? err('toList: expected a Multiset') : mentionsAgent(l.of) ? err('toList: anonymous agents have no order') : T.list(l.of) },
+    /** All sub-collections, smallest first. */
+    subsets: { arity: 1, ret: ([l]) => collection('subsets', l) ?? T.list(l) },
+    /** Sub-collections with at most `k` elements. */
+    subsetsUpTo: {
+        arity: 2,
+        ret: ([l, k]) => collection('subsetsUpTo', l) ?? (k.k === 'nat' ? T.list(l) : err('subsetsUpTo: expected a Nat bound')),
+    },
+    /** Removes repeated elements. */
+    dedup: { arity: 1, ret: ([l]) => collection('dedup', l) ?? l },
+    /** Multiset difference. */
+    diff: { arity: 2, ret: ([a, b]) => a.k === 'multiset' && typeEq(a, b) ? a : err('diff: expected two Multisets of the same type') },
+    /** `[a, b, c]` (an empty list is a literal). */
+    list: { ret: args => args.every(a => typeEq(a, args[0])) ? T.list(args[0]) : err('list: elements of different types') },
+    at: { arity: 2, ret: ([l, i]) => l.k === 'list' && i.k === 'nat' ? l.of : err('at: expected a List and a Nat') },
+    append: { arity: 2, ret: ([a, b]) => isCollection(a) && typeEq(a, b) ? a : err('append: expected two collections of the same type') },
+    ofFn: {
+        arity: 2,
+        lambdas: { 1: () => [T.nat] },
+        ret: ([n, f]) => n.k === 'nat' && f.k === 'fn' ? T.list(f.ret) : err('ofFn: expected a Nat and a function'),
+    },
+    // Labels
+    show: { arity: 1, ret: () => T.string },
+    concat: { ret: args => args.every(a => a.k === 'string') ? T.string : err('concat: expected strings') },
+    // Configurations and agents
+    /** A multiset: anonymous agents have no order. */
+    agents: { arity: 1, config: true, only: CONFIG_CONTEXTS, ret: ([c]) => c.k === 'config' ? T.multiset(T.agent) : err('agents: expected a Config') },
+    nodes: { arity: 1, config: true, only: CONFIG_CONTEXTS, ret: ([c]) => c.k === 'config' ? T.list(T.node) : err('nodes: expected a Config') },
+    size: { arity: 1, config: true, only: CONFIG_CONTEXTS, ret: ([c]) => c.k === 'config' ? T.nat : err('size: expected a Config') },
+    /** No flag is raised. */
+    correct: { arity: 1, config: true, ret: ([a]) => a.k === 'agent' ? T.bool : err('correct: expected an Agent') },
+    /** No hidden flag is raised. */
+    present: { arity: 1, config: true, ret: ([a]) => a.k === 'agent' ? T.bool : err('present: expected an Agent') },
+    /** The decision of an agent this round; `decided` is false for agents that did not decide (then `move` is `stay`). */
+    decisionOf: { arity: 1, config: true, only: ['beforeMove'], ret: ([a]) => a.k === 'agent' ? T.decision : err('decisionOf: expected an Agent') },
+    // Topology
+    /** The neighbour in a global direction (whether or not the edge is present). */
+    target: { arity: 2, config: true, ret: ([n, m]) => n.k === 'node' && m.k === 'move' ? T.node : err('target: expected a Node and a Move') },
+    /** The node reached from a node after `i` steps in a global direction (edges present or not). */
+    advance: {
+        arity: 3, config: true,
+        ret: ([n, m, i]) => n.k === 'node' && m.k === 'move' && i.k === 'nat' ? T.node : err('advance: expected a Node, a Move and a Nat'),
+    },
+    /** Whether the edge from a node in a global direction is present in this round. */
+    edgePresent: { arity: 2, config: true, ret: ([n, m]) => n.k === 'node' && m.k === 'move' ? T.bool : err('edgePresent: expected a Node and a Move') },
+    /** The node seen at local offset `i` from a node, in a frame. */
+    offset: {
+        arity: 3, config: true,
+        ret: ([n, f, i]) => n.k === 'node' && f.k === 'frame' && i.k === 'nat' ? T.node : err('offset: expected a Node, a Frame and a Nat'),
+    },
+    /** A local move, mapped to a global one through a frame. */
+    toGlobal: { arity: 2, ret: ([f, m]) => f.k === 'frame' && m.k === 'move' ? T.move : err('toGlobal: expected a Frame and a Move') },
+    opposite: { arity: 1, ret: ([m]) => m.k === 'move' ? T.move : err('opposite: expected a Move') },
+    /** Every frame of the topology. */
+    frames: { arity: 0, ret: () => T.list(T.frame) },
+    /** Node number `n` (modulo the size). Only in initialisation. */
+    node: { arity: 1, config: true, absolute: true, only: ['init', 'domain'], ret: ([n]) => n.k === 'nat' ? T.node : err('node: expected a Nat') },
+};