use crate::engine::{Ast, Engine, ExecError};
use crate::{
BreakpointSet, EngineError, NodeContext, Path, Pending, StepOutcome, Stepper, SuspendReason,
SuspensionId,
};
#[derive(Debug)]
pub enum DriveOutcome<V> {
Done(V),
Break {
at: Vec<Pending>,
},
}
pub trait EffectResolver<A: Ast> {
fn resolve(&mut self, pending: &Pending) -> Result<A::Value, A::EffectError>;
fn cancelled(&mut self, _sid: SuspensionId) {}
}
pub trait AsyncEffectResolver<A: Ast> {
fn resolve(
&mut self,
pending: &Pending,
) -> impl Future<Output = Result<A::Value, A::EffectError>> + Send;
fn cancelled(&mut self, _sid: SuspensionId) {}
}
pub fn drive<A, R>(
engine: &mut Engine<A>,
resolver: &mut R,
bps: &BreakpointSet,
) -> Result<DriveOutcome<A::Value>, ExecError<A::EffectError>>
where
A: Ast,
R: EffectResolver<A>,
{
loop {
let outcome = engine.run_to_yield_with_breakpoints(bps)?;
notify_cancellations(engine, |sid| resolver.cancelled(sid));
match outcome {
StepOutcome::Done(v) => return Ok(DriveOutcome::Done(v)),
StepOutcome::Ready => unreachable!("run_to_yield never returns Ready"),
StepOutcome::Blocked { .. } => match next_call(engine)? {
NextCall::Break(at) => return Ok(DriveOutcome::Break { at }),
NextCall::Resolve(p) => {
let result = resolver.resolve(&p);
engine.resolve(p.id, result)?;
notify_cancellations(engine, |sid| resolver.cancelled(sid));
}
},
}
}
}
pub async fn drive_async<A, R>(
engine: &mut Engine<A>,
resolver: &mut R,
bps: &BreakpointSet,
) -> Result<DriveOutcome<A::Value>, ExecError<A::EffectError>>
where
A: Ast,
R: AsyncEffectResolver<A>,
{
loop {
let outcome = engine.run_to_yield_with_breakpoints(bps)?;
notify_cancellations(engine, |sid| resolver.cancelled(sid));
match outcome {
StepOutcome::Done(v) => return Ok(DriveOutcome::Done(v)),
StepOutcome::Ready => unreachable!("run_to_yield never returns Ready"),
StepOutcome::Blocked { .. } => match next_call(engine)? {
NextCall::Break(at) => return Ok(DriveOutcome::Break { at }),
NextCall::Resolve(p) => {
let result = resolver.resolve(&p).await;
engine.resolve(p.id, result)?;
notify_cancellations(engine, |sid| resolver.cancelled(sid));
}
},
}
}
}
enum NextCall {
Break(Vec<Pending>),
Resolve(Pending),
}
fn next_call<A: Ast>(engine: &Engine<A>) -> Result<NextCall, ExecError<A::EffectError>> {
let pending = engine.pending();
if pending
.iter()
.any(|p| !matches!(p.reason, SuspendReason::Call { .. }))
{
return Ok(NextCall::Break(pending.to_vec()));
}
match pending.first() {
Some(p) => Ok(NextCall::Resolve(p.clone())),
None => {
let root = engine.root_node();
Err(ExecError::Engine(EngineError::StepperProtocol {
at: NodeContext::at(root, Path::root().push(root)),
detail: "engine blocked with no pending suspensions".into(),
}))
}
}
}
fn notify_cancellations<A: Ast>(engine: &mut Engine<A>, mut f: impl FnMut(SuspensionId)) {
for sid in engine.take_cancellations() {
f(sid);
}
}