updated all deps

migrated away from paste and async-std

orchid-extension/src/coroutine_exec.rs

@@ -3,10 +3,10 @@ use std::marker::PhantomData;
 use std::pin::Pin;
 use std::rc::Rc;
 
-use async_std::channel::{Receiver, RecvError, Sender, bounded};
-use async_std::sync::Mutex;
+use futures::channel::mpsc::{Receiver, Sender, channel};
 use futures::future::Fuse;
-use futures::{FutureExt, select};
+use futures::lock::Mutex;
+use futures::{FutureExt, SinkExt, StreamExt, select};
 use never::Never;
 use orchid_base::error::OrcRes;
 
@@ -22,20 +22,20 @@ enum Command {
 }
 
 struct BuilderCoroutineData {
-	work: Mutex<Fuse<Pin<Box<dyn Future<Output = GExpr>>>>>,
+	work: Fuse<Pin<Box<dyn Future<Output = GExpr>>>>,
 	cmd_recv: Receiver<Command>,
 }
 #[derive(Clone)]
-struct BuilderCoroutine(Rc<BuilderCoroutineData>);
+struct BuilderCoroutine(Rc<Mutex<BuilderCoroutineData>>);
 impl BuilderCoroutine {
 	pub async fn run(self) -> GExpr {
 		let cmd = {
-			let mut work = self.0.work.lock().await;
+			let this = &mut *self.0.lock().await;
 			select! {
-				ret_val = &mut *work => { return ret_val },
-				cmd_res = self.0.cmd_recv.recv().fuse() => match cmd_res {
-					Ok(cmd) => cmd,
-					Err(RecvError) => return (&mut *work).await
+				ret_val = &mut this.work => { return ret_val },
+				cmd_res = this.cmd_recv.next().fuse() => match cmd_res {
+					Some(cmd) => cmd,
+					None => return (&mut this.work).await
 				},
 			}
 		};
@@ -65,17 +65,17 @@ impl Atomic for Replier {
 impl OwnedAtom for Replier {
 	type Refs = Never;
 	async fn val(&self) -> Cow<'_, Self::Data> { Cow::Owned(()) }
-	async fn call(self, arg: Expr) -> GExpr {
+	async fn call(mut self, arg: Expr) -> GExpr {
 		let _ = self.reply.send(arg).await;
 		self.builder.run().await
 	}
 }
 
 pub async fn exec<R: ToExpr>(f: impl for<'a> AsyncFnOnce(ExecHandle<'a>) -> R + 'static) -> GExpr {
-	let (cmd_snd, cmd_recv) = bounded(1);
+	let (cmd_snd, cmd_recv) = channel(0);
 	let work =
 		async { f(ExecHandle(cmd_snd, PhantomData)).await.to_expr().await }.boxed_local().fuse();
-	let coro = BuilderCoroutine(Rc::new(BuilderCoroutineData { cmd_recv, work: Mutex::new(work) }));
+	let coro = BuilderCoroutine(Rc::new(Mutex::new(BuilderCoroutineData { cmd_recv, work })));
 	coro.run().await
 }
 
@@ -84,13 +84,13 @@ static WEIRD_DROP_ERR: &str = "Coroutine dropped while we are being polled someh
 pub struct ExecHandle<'a>(Sender<Command>, PhantomData<&'a ()>);
 impl ExecHandle<'_> {
 	pub async fn exec<T: TryFromExpr>(&mut self, val: impl ToExpr) -> OrcRes<T> {
-		let (reply_snd, reply_recv) = bounded(1);
+		let (reply_snd, mut reply_recv) = channel(0);
 		self.0.send(Command::Execute(val.to_expr().await, reply_snd)).await.expect(WEIRD_DROP_ERR);
-		T::try_from_expr(reply_recv.recv().await.expect(WEIRD_DROP_ERR)).await
+		T::try_from_expr(reply_recv.next().await.expect(WEIRD_DROP_ERR)).await
 	}
 	pub async fn register(&mut self, val: impl ToExpr) -> Expr {
-		let (reply_snd, reply_recv) = bounded(1);
+		let (reply_snd, mut reply_recv) = channel(0);
 		self.0.send(Command::Register(val.to_expr().await, reply_snd)).await.expect(WEIRD_DROP_ERR);
-		reply_recv.recv().await.expect(WEIRD_DROP_ERR)
+		reply_recv.next().await.expect(WEIRD_DROP_ERR)
 	}
 }