Lawrence Bethlenfalvy
0909524dee
Some checks failed
Rust / build (push) Failing after 3m52s
terrified to start testing
83 lines
2.7 KiB
Rust
83 lines
2.7 KiB
Rust
use std::borrow::Cow;
|
|
use std::marker::PhantomData;
|
|
use std::rc::Rc;
|
|
|
|
use futures::channel::mpsc::{Sender, channel};
|
|
use futures::lock::Mutex;
|
|
use futures::stream::{self, LocalBoxStream};
|
|
use futures::{FutureExt, SinkExt, StreamExt};
|
|
use never::Never;
|
|
use orchid_base::OrcRes;
|
|
|
|
use crate::gen_expr::{GExpr, arg, call, lam, new_atom, seq};
|
|
use crate::{Atomic, Expr, OwnedAtom, OwnedVariant, ToExpr, TryFromExpr};
|
|
|
|
enum Command {
|
|
Execute(GExpr, Sender<Expr>),
|
|
Halt(GExpr),
|
|
}
|
|
|
|
struct BuilderCoroutineData {
|
|
receiver: Mutex<LocalBoxStream<'static, Command>>,
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
struct BuilderCoroutine(Rc<BuilderCoroutineData>);
|
|
impl BuilderCoroutine {
|
|
pub async fn run(self) -> GExpr {
|
|
let cmd = self.0.receiver.lock().await.next().await;
|
|
match cmd {
|
|
None => panic!("Exec handle dropped and coroutine blocked instead of returning"),
|
|
Some(Command::Halt(expr)) => expr,
|
|
Some(Command::Execute(expr, reply)) =>
|
|
call(lam::<0>(seq(arg(0), call(new_atom(Replier { reply, builder: self }), arg(0)))), expr)
|
|
.await,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone)]
|
|
pub(crate) struct Replier {
|
|
reply: Sender<Expr>,
|
|
builder: BuilderCoroutine,
|
|
}
|
|
impl Atomic for Replier {
|
|
type Data = ();
|
|
type Variant = OwnedVariant;
|
|
}
|
|
impl OwnedAtom for Replier {
|
|
type Refs = Never;
|
|
async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(()) }
|
|
async fn call(mut self, arg: Expr) -> impl ToExpr {
|
|
self.reply.send(arg).await.expect("Resolution request dropped after sending");
|
|
std::mem::drop(self.reply);
|
|
self.builder.run().await
|
|
}
|
|
}
|
|
|
|
/// A long-lived async context that can yield to the executor. The expression
|
|
/// representing an in-progress exec block is not serializable.
|
|
pub async fn exec<R: ToExpr>(f: impl for<'a> AsyncFnOnce(ExecHandle<'a>) -> R + 'static) -> GExpr {
|
|
let (cmd_snd, cmd_recv) = channel(0);
|
|
let halt =
|
|
async { Command::Halt(f(ExecHandle(cmd_snd, PhantomData)).await.to_gen().await) }.into_stream();
|
|
let coro = BuilderCoroutine(Rc::new(BuilderCoroutineData {
|
|
receiver: Mutex::new(stream::select(halt, cmd_recv).boxed_local()),
|
|
}));
|
|
coro.run().await
|
|
}
|
|
|
|
static WEIRD_DROP_ERR: &str = "Coroutine dropped while we are being polled somehow";
|
|
|
|
/// The handle an [exec] callback uses to yield to the executor
|
|
pub struct ExecHandle<'a>(Sender<Command>, PhantomData<&'a ()>);
|
|
impl ExecHandle<'_> {
|
|
/// Yield to the executor by resolving to an expression that normalizes the
|
|
/// value and then calls the continuation of the body with the result.
|
|
pub async fn exec<T: TryFromExpr>(&mut self, val: impl ToExpr) -> OrcRes<T> {
|
|
let (reply_snd, mut reply_recv) = channel(1);
|
|
self.0.send(Command::Execute(val.to_gen().await, reply_snd)).await.expect(WEIRD_DROP_ERR);
|
|
T::try_from_expr(reply_recv.next().await.expect(WEIRD_DROP_ERR)).await
|
|
}
|
|
}
|