use std::collections::HashMap;
use std::sync::mpsc::{self, Receiver, Sender};
use std::sync::{Arc, Mutex};
use std::thread::JoinHandle;
use crate::expr::{self, Expr};
#[derive(Debug, Clone)]
pub enum Stmt {
Assign(String, Expr),
Reply(Expr),
}
#[derive(Debug, Clone)]
pub struct Handler {
pub msg: String,
pub params: Vec<String>,
pub body: Vec<Stmt>,
}
#[derive(Debug, Clone)]
pub struct ActorDef {
pub name: String,
pub state_param: Option<String>,
pub handlers: Vec<Handler>,
}
impl ActorDef {
fn handler(&self, msg: &str) -> Option<&Handler> {
self.handlers.iter().find(|h| h.msg == msg)
}
}
pub fn parse_actor(args: &[crate::ast::Arg]) -> Result<ActorDef, String> {
use crate::ast::Arg;
let header = args
.first()
.and_then(Arg::as_str)
.ok_or("actor: expected `actor NAME(state) { ⦠}`")?;
let (name, state_param) = split_header(header)?;
if name.is_empty() {
return Err("actor: missing name".into());
}
let block = match args.get(1) {
Some(Arg::Block(cmds)) => cmds,
_ => return Err("actor: expected `{ on MSG { ⦠} }` handler block".into()),
};
let mut handlers = Vec::new();
for c in block {
if c.name != "on" {
return Err(format!(
"actor: expected `on MSG {{ ⦠}}`, got `{}`",
c.name
));
}
let sig = c
.args
.first()
.and_then(Arg::as_str)
.ok_or("actor: `on` needs a message name")?;
let (msg, params) = split_call(sig);
let body_cmds = match c.args.get(1) {
Some(Arg::Block(b)) => b,
_ => return Err(format!("actor: `on {msg}` needs a `{{ ⦠}}` body")),
};
if c.args.len() > 2 {
return Err(format!(
"actor: `on {msg}` has trailing tokens ā separate handlers by a newline or `;`"
));
}
handlers.push(Handler {
msg,
params,
body: parse_body(body_cmds)?,
});
}
if handlers.is_empty() {
return Err("actor: needs at least one `on MSG { ⦠}` handler".into());
}
Ok(ActorDef {
name,
state_param,
handlers,
})
}
fn split_header(h: &str) -> Result<(String, Option<String>), String> {
let (name, params) = split_call(h);
match params.len() {
0 => Ok((name, None)),
1 => Ok((name, Some(params.into_iter().next().unwrap()))),
_ => Err(format!("actor: `{name}` takes a single state parameter")),
}
}
fn split_call(s: &str) -> (String, Vec<String>) {
let s = s.trim();
match s.find('(') {
None => (s.to_string(), Vec::new()),
Some(i) => {
let name = s[..i].trim().to_string();
let inner = s[i + 1..].trim_end_matches(')');
let params = inner
.split(',')
.map(str::trim)
.filter(|p| !p.is_empty())
.map(str::to_string)
.collect();
(name, params)
}
}
}
fn parse_body(cmds: &[crate::ast::Command]) -> Result<Vec<Stmt>, String> {
let mut out = Vec::with_capacity(cmds.len());
for c in cmds {
if c.name == "reply" {
out.push(Stmt::Reply(parse_expr_args(&c.args)?));
} else if c.args.first().and_then(crate::ast::Arg::as_str) == Some("=") {
out.push(Stmt::Assign(c.name.clone(), parse_expr_args(&c.args[1..])?));
} else if let Some((lhs, rhs)) = c.name.split_once('=') {
let var = lhs.trim();
if var.is_empty() || !var.chars().all(|ch| ch.is_alphanumeric() || ch == '_') {
return Err(format!(
"actor: `{}` is not a valid assignment target",
c.name
));
}
let mut expr = rhs.trim().to_string();
for a in &c.args {
let s = a
.as_str()
.ok_or("actor: a `{ ⦠}` block is not an expression")?;
expr.push(' ');
expr.push_str(s);
}
out.push(Stmt::Assign(var.to_string(), expr::parse(expr.trim())?));
} else {
return Err(format!(
"actor: handler statement must be `reply EXPR` or `var = EXPR`, got `{}`",
c.name
));
}
}
Ok(out)
}
fn parse_expr_args(args: &[crate::ast::Arg]) -> Result<Expr, String> {
let mut parts = Vec::with_capacity(args.len());
for a in args {
match a.as_str() {
Some(s) => parts.push(s),
None => return Err("actor: a `{ ⦠}` block is not an expression".into()),
}
}
if parts.is_empty() {
return Err("actor: empty expression".into());
}
expr::parse(&parts.join(" "))
}
fn run_handler(h: &Handler, env: &mut HashMap<String, f64>) -> Option<f64> {
let mut reply = None;
for st in &h.body {
match st {
Stmt::Assign(name, e) => {
let v = eval_env(e, env);
env.insert(name.clone(), v);
}
Stmt::Reply(e) => reply = Some(eval_env(e, env)),
}
}
reply
}
fn eval_env(e: &Expr, env: &HashMap<String, f64>) -> f64 {
let x = env.get("x").copied().unwrap_or(0.0);
let resolve = |name: &str| env.get(name).copied().unwrap_or(0.0);
expr::eval_ctx(e, x, &resolve).unwrap_or(f64::NAN)
}
struct Message {
name: String,
args: Vec<f64>,
reply: Option<Sender<f64>>,
}
#[derive(Clone)]
pub struct ActorRef {
tx: Sender<Message>,
}
impl ActorRef {
pub fn send(&self, msg: &str, args: Vec<f64>) -> bool {
self.tx
.send(Message {
name: msg.to_string(),
args,
reply: None,
})
.is_ok()
}
pub fn ask(&self, msg: &str, args: Vec<f64>) -> Option<f64> {
let (rtx, rrx) = mpsc::channel();
self.tx
.send(Message {
name: msg.to_string(),
args,
reply: Some(rtx),
})
.ok()?;
rrx.recv().ok()
}
}
#[derive(Default)]
pub struct ActorSystem {
handles: Vec<JoinHandle<()>>,
}
impl ActorSystem {
pub fn new() -> Self {
Self::default()
}
pub fn spawn(&mut self, def: Arc<ActorDef>, init: f64) -> ActorRef {
let (tx, rx) = mpsc::channel::<Message>();
let handle = std::thread::spawn(move || actor_loop(&def, init, rx));
self.handles.push(handle);
ActorRef { tx }
}
pub fn pool(&mut self, def: Arc<ActorDef>, n: usize, init: f64) -> Pool {
let n = n.max(1);
let refs = (0..n).map(|_| self.spawn(def.clone(), init)).collect();
Pool {
def,
init,
refs: Mutex::new(refs),
next: Mutex::new(0),
}
}
}
impl Drop for ActorSystem {
fn drop(&mut self) {
for h in self.handles.drain(..) {
let _ = h.join();
}
}
}
fn actor_loop(def: &ActorDef, init: f64, rx: Receiver<Message>) {
let mut state = init;
while let Ok(msg) = rx.recv() {
let Some(h) = def.handler(&msg.name) else {
if let Some(r) = msg.reply {
let _ = r.send(state);
}
continue;
};
let mut env_map: HashMap<String, f64> = HashMap::new();
if let Some(sp) = &def.state_param {
env_map.insert(sp.clone(), state);
}
for (p, v) in h.params.iter().zip(msg.args.iter()) {
env_map.insert(p.clone(), *v);
}
let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
run_handler(h, &mut env_map)
}));
match result {
Ok(reply) => {
if let Some(sp) = &def.state_param {
if let Some(v) = env_map.get(sp) {
state = *v;
}
}
if let Some(r) = msg.reply {
let _ = r.send(reply.unwrap_or(state));
}
}
Err(_) => {
state = init;
if let Some(r) = msg.reply {
let _ = r.send(state);
}
}
}
}
}
pub struct Pool {
def: Arc<ActorDef>,
init: f64,
refs: Mutex<Vec<ActorRef>>,
next: Mutex<usize>,
}
impl Pool {
pub fn size(&self) -> usize {
self.refs.lock().unwrap().len()
}
pub fn ask(&self, sys: &Mutex<ActorSystem>, msg: &str, args: Vec<f64>) -> Option<f64> {
let (idx, worker) = {
let refs = self.refs.lock().unwrap();
let len = refs.len().max(1);
let mut n = self.next.lock().unwrap();
let i = *n % len;
*n = i + 1;
(i, refs.get(i).cloned())
};
if let Some(w) = worker {
if let Some(v) = w.ask(msg, args.clone()) {
return Some(v);
}
}
let fresh = sys.lock().unwrap().spawn(self.def.clone(), self.init);
let v = fresh.ask(msg, args);
if let Some(slot) = self.refs.lock().unwrap().get_mut(idx) {
*slot = fresh;
}
v
}
}
fn default_workers() -> usize {
std::thread::available_parallelism()
.map(|n| n.get())
.unwrap_or(4)
}
pub fn run_via(def: &Arc<ActorDef>, workers: usize, lines: &[String]) -> Vec<String> {
if lines.is_empty() {
return Vec::new();
}
let n = if workers == 0 {
default_workers()
} else {
workers
}
.min(lines.len().max(1));
let msg = def.handlers[0].msg.clone();
let reply = |l: &String, v: Option<f64>| match v {
Some(v) => crate::query::fmt_scalar(v),
None => l.clone(),
};
let mut sys = ActorSystem::new();
if n == 1 {
let r = sys.spawn(def.clone(), 0.0);
return lines
.iter()
.map(|l| reply(l, r.ask(&msg, vec![crate::spec::parse_scalar(l)])))
.collect();
}
let sys = Mutex::new(sys);
let pool = {
let mut s = sys.lock().unwrap();
s.pool(def.clone(), n, 0.0)
};
use rayon::prelude::*;
lines
.par_iter()
.map(|l| reply(l, pool.ask(&sys, &msg, vec![crate::spec::parse_scalar(l)])))
.collect()
}
#[derive(Debug, Clone)]
pub struct RefDecl {
pub name: String,
pub actor: String,
pub init: f64,
pub pool: Option<usize>,
pub restart: bool,
}
enum Target {
One(ActorRef),
Pool {
workers: Vec<ActorRef>,
next: usize,
def: Arc<ActorDef>,
init: f64,
restart: bool,
},
}
#[derive(Default)]
pub struct Session {
refs: HashMap<String, Target>,
sys: ActorSystem,
}
impl Session {
pub fn build(
defs: &std::collections::BTreeMap<String, Arc<ActorDef>>,
decls: &[RefDecl],
) -> Result<Session, String> {
let mut s = Session::default();
for d in decls {
let def = defs
.get(&d.actor)
.ok_or_else(|| format!("spawn: no actor named `{}`", d.actor))?
.clone();
let target = match d.pool {
Some(n) => {
let n = n.max(1);
Target::Pool {
workers: (0..n).map(|_| s.sys.spawn(def.clone(), d.init)).collect(),
next: 0,
def,
init: d.init,
restart: d.restart,
}
}
None => Target::One(s.sys.spawn(def, d.init)),
};
s.refs.insert(d.name.clone(), target);
}
Ok(s)
}
pub fn is_empty(&self) -> bool {
self.refs.is_empty()
}
fn worker(&mut self, name: &str) -> Option<ActorRef> {
match self.refs.get_mut(name)? {
Target::One(r) => Some(r.clone()),
Target::Pool {
workers,
next,
def,
init,
restart,
} => {
if workers.is_empty() {
return None;
}
let i = *next % workers.len();
*next = i + 1;
if *restart {
let probe = mpsc::channel::<f64>().0;
let dead = workers[i]
.tx
.send(Message {
name: String::new(),
args: Vec::new(),
reply: Some(probe),
})
.is_err();
if dead {
workers[i] = self.sys.spawn(def.clone(), *init);
}
}
Some(workers[i].clone())
}
}
}
pub fn tell(&mut self, name: &str, msg: &str, args: Vec<f64>) {
if let Some(w) = self.worker(name) {
w.send(msg, args);
}
}
pub fn ask(&mut self, name: &str, msg: &str, args: Vec<f64>) -> Option<f64> {
self.worker(name).and_then(|w| w.ask(msg, args))
}
}
pub fn parse_call(s: &str) -> Result<(String, Vec<Expr>), String> {
let s = s.trim();
let open = match s.find('(') {
None => return Ok((s.to_string(), Vec::new())),
Some(i) => i,
};
let name = s[..open].trim().to_string();
if name.is_empty() {
return Err("message call: missing name".into());
}
let inner = s
.strip_suffix(')')
.and_then(|s| s.get(open + 1..))
.ok_or("message call: unbalanced `()`")?;
let mut args = Vec::new();
let (mut depth, mut start) = (0isize, 0usize);
for (i, ch) in inner.char_indices() {
match ch {
'(' => depth += 1,
')' => depth -= 1,
',' if depth == 0 => {
push_arg(&inner[start..i], &mut args)?;
start = i + 1;
}
_ => {}
}
}
if !inner.trim().is_empty() {
push_arg(&inner[start..], &mut args)?;
}
Ok((name, args))
}
fn push_arg(raw: &str, out: &mut Vec<Expr>) -> Result<(), String> {
let t = raw.trim();
if t.is_empty() {
return Err("message call: empty argument".into());
}
out.push(expr::parse(t)?);
Ok(())
}
pub fn eval_args(exprs: &[Expr], inputs: &HashMap<String, String>) -> Vec<f64> {
let num = |n: &str| -> Option<f64> { inputs.get(n).and_then(|v| v.trim().parse::<f64>().ok()) };
let strv = |n: &str| -> Option<String> { inputs.get(n).cloned() };
exprs
.iter()
.map(|e| {
let sub = expr::substitute_controls(e, &num, &strv);
expr::eval(&sub, 0.0).unwrap_or(f64::NAN)
})
.collect()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::parser::parse;
fn def(src: &str) -> Arc<ActorDef> {
let cmds = parse(src).unwrap();
Arc::new(parse_actor(&cmds[0].args).unwrap())
}
#[test]
fn parses_header_and_handlers() {
let d =
def("actor worker(state) {\n on job(x) { reply x * 2 }\n on reset { state = 0 }\n }");
assert_eq!(d.name, "worker");
assert_eq!(d.state_param.as_deref(), Some("state"));
assert_eq!(d.handlers.len(), 2);
assert_eq!(d.handlers[0].msg, "job");
assert_eq!(d.handlers[0].params, vec!["x".to_string()]);
assert_eq!(d.handlers[1].msg, "reset");
assert!(d.handlers[1].params.is_empty());
}
#[test]
fn unspaced_assignment_is_accepted() {
let d = def("actor c(state) { on tick { state=state+1; reply state } }");
let mut sys = ActorSystem::new();
let r = sys.spawn(d, 0.0);
assert_eq!(r.ask("tick", vec![]), Some(1.0));
assert_eq!(r.ask("tick", vec![]), Some(2.0));
}
#[test]
fn header_without_state_is_allowed() {
let d = def("actor doubler { on job(x) { reply x + x } }");
assert!(d.state_param.is_none());
}
#[test]
fn spawn_send_ask_roundtrip() {
let d = def("actor w(state) { on job(x) { reply x * 3 } }");
let mut sys = ActorSystem::new();
let r = sys.spawn(d, 0.0);
assert_eq!(r.ask("job", vec![7.0]), Some(21.0));
}
#[test]
fn state_persists_across_messages() {
let d = def("actor acc(state) { on add(n) { state = state + n; reply state } }");
let mut sys = ActorSystem::new();
let r = sys.spawn(d, 0.0);
assert_eq!(r.ask("add", vec![10.0]), Some(10.0));
assert_eq!(r.ask("add", vec![5.0]), Some(15.0));
assert_eq!(r.ask("add", vec![100.0]), Some(115.0));
}
#[test]
fn tell_is_fire_and_forget() {
let d = def("actor sink(state) { on set(v) { state = v; reply state } }");
let mut sys = ActorSystem::new();
let r = sys.spawn(d, 0.0);
assert!(r.send("set", vec![42.0]));
assert_eq!(r.ask("set", vec![9.0]), Some(9.0));
}
#[test]
fn unknown_message_replies_state_not_hang() {
let d = def("actor w(state) { on job(x) { reply x } }");
let mut sys = ActorSystem::new();
let r = sys.spawn(d, 3.0);
assert_eq!(r.ask("nope", vec![]), Some(3.0));
}
#[test]
fn via_is_a_deterministic_parallel_map() {
let d = def("actor sq(state) { on job(x) { reply x * x } }");
let lines: Vec<String> = (1..=6).map(|i| i.to_string()).collect();
let out = run_via(&d, 4, &lines);
assert_eq!(out, vec!["1", "4", "9", "16", "25", "36"]);
}
#[test]
fn via_preserves_order_with_single_worker() {
let d = def("actor inc(state) { on job(x) { reply x + 1 } }");
let lines: Vec<String> = vec!["10".into(), "20".into(), "30".into()];
assert_eq!(run_via(&d, 1, &lines), vec!["11", "21", "31"]);
}
#[test]
fn via_single_worker_is_a_sequential_accumulator() {
let d = def("actor acc(state) { on job(x) { state = state + x; reply state } }");
let lines: Vec<String> = vec!["10".into(), "5".into(), "100".into()];
assert_eq!(run_via(&d, 1, &lines), vec!["10", "15", "115"]);
}
fn reg(src: &str) -> std::collections::BTreeMap<String, Arc<ActorDef>> {
let mut m = std::collections::BTreeMap::new();
let d = def(src);
m.insert(d.name.clone(), d);
m
}
#[test]
fn session_spawn_tell_ask() {
let defs = reg("actor acc(state) { on add(n) { state = state + n; reply state } }");
let decls = vec![RefDecl {
name: "w".into(),
actor: "acc".into(),
init: 100.0,
pool: None,
restart: true,
}];
let mut s = Session::build(&defs, &decls).unwrap();
s.tell("w", "add", vec![5.0]); assert_eq!(s.ask("w", "add", vec![10.0]), Some(115.0));
s.tell("ghost", "add", vec![1.0]);
assert_eq!(s.ask("ghost", "add", vec![1.0]), None);
}
#[test]
fn session_pool_round_robins() {
let defs = reg("actor id(state) { on get { reply state } }");
let decls = vec![RefDecl {
name: "p".into(),
actor: "id".into(),
init: 7.0,
pool: Some(3),
restart: true,
}];
let mut s = Session::build(&defs, &decls).unwrap();
assert_eq!(s.ask("p", "get", vec![]), Some(7.0));
assert_eq!(s.ask("p", "get", vec![]), Some(7.0));
}
#[test]
fn supervised_pool_respawns_but_failstop_does_not() {
let defs = reg("actor w(state) { on job(x) { reply x + 1 } }");
let mut sup = Session::build(
&defs,
&[RefDecl {
name: "p".into(),
actor: "w".into(),
init: 0.0,
pool: Some(1),
restart: true,
}],
)
.unwrap();
kill_pool_worker(&mut sup, "p");
assert_eq!(sup.ask("p", "job", vec![41.0]), Some(42.0));
let mut fs = Session::build(
&defs,
&[RefDecl {
name: "p".into(),
actor: "w".into(),
init: 0.0,
pool: Some(1),
restart: false,
}],
)
.unwrap();
kill_pool_worker(&mut fs, "p");
assert_eq!(fs.ask("p", "job", vec![41.0]), None);
}
fn kill_pool_worker(s: &mut Session, name: &str) {
if let Some(Target::Pool { workers, .. }) = s.refs.get_mut(name) {
let (tx, rx) = mpsc::channel();
drop(rx);
workers[0] = ActorRef { tx };
}
}
#[test]
fn spec_build_parses_refs_actions_and_supervise() {
use crate::spec::{self, BindAction};
let src = "\
actor worker(state) { on job(x) { reply x * 2 } }\n\
spawn w = worker(3)\n\
pool p = worker * 4\n\
supervise p { on crash { stop } }\n\
bind C-t tell w job(5)\n\
bind C-a ask .out p job(.th)\n";
let sp = spec::build(&parse(src).unwrap()).unwrap();
assert_eq!(sp.actor_refs.len(), 2);
let w = &sp.actor_refs[0];
assert_eq!(
(w.name.as_str(), w.actor.as_str(), w.init, w.pool),
("w", "worker", 3.0, None)
);
let p = &sp.actor_refs[1];
assert_eq!((p.name.as_str(), p.pool, p.restart), ("p", Some(4), false)); let tell = sp.binds.iter().find_map(|b| match &b.action {
BindAction::ActorTell { refname, call } => Some((refname.clone(), call.clone())),
_ => None,
});
assert_eq!(tell, Some(("w".to_string(), "job(5)".to_string())));
let ask = sp.binds.iter().find_map(|b| match &b.action {
BindAction::ActorAsk {
ctrl,
refname,
call,
} => Some((ctrl.clone(), refname.clone(), call.clone())),
_ => None,
});
assert_eq!(
ask,
Some(("out".to_string(), "p".to_string(), "job(.th)".to_string()))
);
}
#[test]
fn parse_call_splits_args_at_depth_zero() {
let (msg, args) = parse_call("job(5, (1 + 2) * 3)").unwrap();
assert_eq!(msg, "job");
assert_eq!(args.len(), 2);
let inputs = HashMap::new();
assert_eq!(eval_args(&args, &inputs), vec![5.0, 9.0]);
}
#[test]
fn eval_args_resolves_controls() {
let (_msg, args) = parse_call("job(.th * 2)").unwrap();
let mut inputs = HashMap::new();
inputs.insert("th".to_string(), "21".to_string());
assert_eq!(eval_args(&args, &inputs), vec![42.0]);
}
#[test]
fn pool_respawns_a_dead_worker() {
let d = def("actor w(state) { on job(x) { reply x + 1 } }");
let sys = Mutex::new(ActorSystem::new());
let pool = sys.lock().unwrap().pool(d.clone(), 2, 0.0);
{
let (tx, rx) = mpsc::channel();
drop(rx);
pool.refs.lock().unwrap()[0] = ActorRef { tx };
}
assert_eq!(pool.ask(&sys, "job", vec![1.0]), Some(2.0));
assert_eq!(pool.ask(&sys, "job", vec![41.0]), Some(42.0));
assert_eq!(pool.size(), 2);
}
}