@bramas/simulant-lang 0.1.2 → 0.3.0

package/dist/builder.js

@@ -208,7 +208,7 @@ 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) }));
+    const params = (spec.params ?? []).map(p => dropUndefined({ name: p.name, type: p.type, domain: p.domain === undefined ? undefined : ir(p.domain), accepts: p.accepts === undefined ? undefined : ir(p.accepts) }));
     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'))) },

package/dist/check.js

@@ -405,6 +405,8 @@ export class Checker {
                 this.report(`parameter ${p.name}: ${showType(p.type)} cannot be stored`);
             if (p.domain)
                 this.root(p.domain, {}, unit('domain', `domain of ${p.name}`), T.list(p.type));
+            if (p.accepts)
+                this.root(p.accepts, {}, unit('domain', `acceptance of ${p.name}`), T.bool);
         }
         this.root(model.topology.size, {}, unit('domain', 'topology size'), T.nat);
         this.root(exp.agents.count, {}, unit('init', 'agent count'), T.nat);

package/dist/elab/elaborate.js

@@ -197,8 +197,13 @@ export class Elaborator {
             case 'ascribe':
                 return this.meval(e.e, env, e.type);
             case 'name':
+                if (e.name === 'none' && expected?.t === 'name' && expected.name === 'Option')
+                    return { m: 'option' };
                 return env.get(e.name) ?? this.metaCall(e.name, [], e.span, env);
             case 'app': {
+                if (e.fn.t === 'name' && e.fn.name === 'some' && expected?.t === 'name' && expected.name === 'Option' && e.args.length === 1) {
+                    return { m: 'option', value: this.meval(e.args[0].value, env, expected.args[0]) };
+                }
                 if (e.fn.t !== 'name')
                     fail('expected the name of a definition', e.fn.span);
                 return this.metaCall(e.fn.name, e.args, e.span, env);
@@ -280,6 +285,7 @@ export class Elaborator {
             case 'str': return v.v;
             case 'enum': return v.ctor;
             case 'list': return v.items.map(i => this.json(i, span));
+            case 'option': return v.value ? this.json(v.value, span) : null;
             default: return fail('expected a value', span);
         }
     }
@@ -611,6 +617,8 @@ export class Elaborator {
             if (i.value.t !== 'nothing')
                 p.domain = this.tr(i.value, { scope: new Map(), params: new Set(paramNames), owner: decl.name });
             paramNames.add(i.name);
+            if (i.param.accepts)
+                p.accepts = this.tr(i.param.accepts, { scope: new Map(), params: new Set(paramNames), owner: decl.name });
             return p;
         });
         const ictx = (extra = []) => ({ scope: new Map(extra), params: paramNames, owner: decl.name });

package/dist/parse/lexer.js

@@ -5,7 +5,7 @@
 export const KEYWORDS = new Set([
     'import', 'def', 'structure', 'inductive', 'sensor', 'task', 'goal', 'algorithm', 'experiment', 'where', 'let',
     'if', 'then', 'else', 'match', 'with', 'fun', 'choose', 'such', 'that', 'labels', 'param', 'flag', 'uses',
-    'true', 'false', 'raise', 'nothing', 'action',
+    'true', 'false', 'raise', 'nothing', 'action', 'in',
 ]);
 /** Operators, longest first. Unicode and ASCII spellings are both accepted. */
 const OPERATORS = [

package/dist/parse/parser.js

@@ -256,13 +256,15 @@ export class Parser {
             if (output)
                 this.next();
             if (this.is('param')) {
-                // `param N : Nat := domain`
+                // `param N : Nat in domain where predicate` (both clauses optional).
+                // Keep `:=` as an alias for the original finite-domain syntax.
                 this.next();
                 const name = this.ident();
                 this.expect(':');
                 const type = this.type();
-                const value = this.is(':=') ? (this.next(), this.expr()) : { t: 'nothing', span: this.span(start) };
-                items.push({ name, args: [], value, span: this.span(start), param: { type } });
+                const value = this.is('in') || this.is(':=') ? (this.next(), this.expr()) : { t: 'nothing', span: this.span(start) };
+                const accepts = this.is('where') ? (this.next(), this.expr()) : undefined;
+                items.push({ name, args: [], value, span: this.span(start), param: { type, ...(accepts ? { accepts } : {}) } });
                 return;
             }
             // Item names may be keywords: `algorithm := ...`, `task := ...`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bramas/simulant-lang",
-  "version": "0.1.2",
+  "version": "0.3.0",
   "private": false,
   "license": "CECILL-B",
   "type": "module",
@@ -20,7 +20,7 @@
     "LICENCE.txt"
   ],
   "dependencies": {
-    "@bramas/simulant-stdlib": "0.1.2"
+    "@bramas/simulant-stdlib": "0.3.0"
   },
   "repository": {
     "type": "git",

package/src/builder.ts

@@ -340,11 +340,11 @@ export function task(spec: { name: string; goal: Goal; verdict: (C: X) => Arg; e
 
 export function experiment(spec: {
   name: string; model: Model; algorithm: Algorithm; task: Task;
-  params?: { name: string; type: Type; domain?: Arg }[];
+  params?: { name: string; type: Type; domain?: Arg; accepts?: Arg }[];
   agents: { count: Arg; pos: (i: X) => Arg };
   limits?: Experiment['limits'];
 }): Experiment {
-  const params: Param[] = (spec.params ?? []).map(p => dropUndefined({ name: p.name, type: p.type, domain: p.domain === undefined ? undefined : ir(p.domain) }));
+  const params: Param[] = (spec.params ?? []).map(p => dropUndefined({ name: p.name, type: p.type, domain: p.domain === undefined ? undefined : ir(p.domain), accepts: p.accepts === undefined ? undefined : ir(p.accepts) }));
   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'))) },

package/src/check.ts

@@ -388,6 +388,7 @@ export class Checker {
     for (const p of exp.params) {
       if (!isStorable(p.type)) this.report(`parameter ${p.name}: ${showType(p.type)} cannot be stored`);
       if (p.domain) this.root(p.domain, {}, unit('domain', `domain of ${p.name}`), T.list(p.type));
+      if (p.accepts) this.root(p.accepts, {}, unit('domain', `acceptance of ${p.name}`), T.bool);
     }
     this.root(model.topology.size, {}, unit('domain', 'topology size'), T.nat);
     this.root(exp.agents.count, {}, unit('init', 'agent count'), T.nat);

package/src/elab/elaborate.ts

@@ -46,6 +46,7 @@ type MV =
   | { m: 'str'; v: string }
   | { m: 'enum'; type: Type & { k: 'enum' }; ctor: string }
   | { m: 'list'; items: MV[] }
+  | { m: 'option'; value?: MV }
   | { m: 'component'; ir: Component }
   | { m: 'model'; ir: Model }
   | { m: 'sensor'; ir: Sensor }
@@ -236,8 +237,12 @@ export class Elaborator {
       case 'ascribe':
         return this.meval(e.e, env, e.type);
       case 'name':
+        if (e.name === 'none' && expected?.t === 'name' && expected.name === 'Option') return { m: 'option' };
         return env.get(e.name) ?? this.metaCall(e.name, [], e.span, env);
       case 'app': {
+        if (e.fn.t === 'name' && e.fn.name === 'some' && expected?.t === 'name' && expected.name === 'Option' && e.args.length === 1) {
+          return { m: 'option', value: this.meval(e.args[0].value, env, expected.args[0]) };
+        }
         if (e.fn.t !== 'name') fail('expected the name of a definition', e.fn.span);
         return this.metaCall((e.fn as { name: string }).name, e.args, e.span, env);
       }
@@ -307,6 +312,7 @@ export class Elaborator {
       case 'nat': case 'bool': case 'str': return v.v;
       case 'enum': return v.ctor;
       case 'list': return v.items.map(i => this.json(i, span));
+      case 'option': return v.value ? this.json(v.value, span) : null;
       default: return fail('expected a value', span);
     }
   }
@@ -618,6 +624,7 @@ export class Elaborator {
       const p: Param = { name: i.name, type: this.type(i.param!.type) };
       if (i.value.t !== 'nothing') p.domain = this.tr(i.value, { scope: new Map(), params: new Set(paramNames), owner: decl.name });
       paramNames.add(i.name);
+      if (i.param!.accepts) p.accepts = this.tr(i.param!.accepts, { scope: new Map(), params: new Set(paramNames), owner: decl.name });
       return p;
     });
     const ictx = (extra: [string, string][] = []): OCtx => ({ scope: new Map(extra), params: paramNames, owner: decl.name });

package/src/ir.ts

@@ -196,8 +196,10 @@ export type Goal =
 /** A verdict on configurations (`C` in scope) and a goal over executions. */
 export type Task = { name: string; verdict: Expr; goal: Goal; equivariance?: Equivariance; defs?: Def[] };
 
-/** A parameter, with the list of its values for `check-all` (earlier parameters in scope). */
-export type Param = { name: string; type: Type; domain?: Expr };
+/** A parameter's domain: an optional exact finite list and/or a Boolean refinement.
+ * Both constraints apply when present. Earlier parameters are in scope in the
+ * list; the refinement also sees the parameter itself. No simulator defaults. */
+export type Param = { name: string; type: Type; domain?: Expr; accepts?: Expr };
 
 /** Where a declaration is written (display only). */
 export type DeclSource = {

package/src/parse/ast.ts

@@ -63,11 +63,11 @@ export type SStmt = { span: Span } & (
   | { s: 'call'; name: string; args: SExpr[] }
 );
 
-/** An item of a `where` block: `name args := value`, or `param N : T := domain` in experiments. */
+/** An item of a `where` block: `name args := value`, or a parameter domain in experiments. */
 export type SWhereItem = {
   name: string; args: string[]; value: SExpr; span: Span;
-  /** `param N : T := domain`, in experiments. */
-  param?: { type: SType };
+  /** `param N : T in domain where predicate`, in experiments (both clauses optional). */
+  param?: { type: SType; accepts?: SExpr };
   /** `def p (x : T) := statements` and `main := statements`, in algorithms. */
   proc?: { params: SBinder[]; body: SStmt[] };
 };

package/src/parse/lexer.ts

@@ -30,7 +30,7 @@ export type Token = {
 export const KEYWORDS = new Set([
   'import', 'def', 'structure', 'inductive', 'sensor', 'task', 'goal', 'algorithm', 'experiment', 'where', 'let',
   'if', 'then', 'else', 'match', 'with', 'fun', 'choose', 'such', 'that', 'labels', 'param', 'flag', 'uses',
-  'true', 'false', 'raise', 'nothing', 'action',
+  'true', 'false', 'raise', 'nothing', 'action', 'in',
 ]);
 
 /** Operators, longest first. Unicode and ASCII spellings are both accepted. */

package/src/parse/parser.ts

@@ -252,13 +252,15 @@ export class Parser {
       const output = algorithm && this.peek().text === 'output' && this.peek(1).kind === 'ident';
       if (output) this.next();
       if (this.is('param')) {
-        // `param N : Nat := domain`
+        // `param N : Nat in domain where predicate` (both clauses optional).
+        // Keep `:=` as an alias for the original finite-domain syntax.
         this.next();
         const name = this.ident();
         this.expect(':');
         const type = this.type();
-        const value: SExpr = this.is(':=') ? (this.next(), this.expr()) : { t: 'nothing', span: this.span(start) };
-        items.push({ name, args: [], value, span: this.span(start), param: { type } });
+        const value: SExpr = this.is('in') || this.is(':=') ? (this.next(), this.expr()) : { t: 'nothing', span: this.span(start) };
+        const accepts = this.is('where') ? (this.next(), this.expr()) : undefined;
+        items.push({ name, args: [], value, span: this.span(start), param: { type, ...(accepts ? { accepts } : {}) } });
         return;
       }
       // Item names may be keywords: `algorithm := ...`, `task := ...`.