remove flume

Author: lherman-cs

Cargo.lock

@@ -25,7 +25,6 @@ rustls = "0.23.31"
 turmoil = "0.6.6"
 quinn-udp = "0.5.14"
 socket2 = "0.6.0"
-flume = "0.11.1"
 no-panic = "0.1.35"
 
 [dev-dependencies]

pulsebeam-runtime/Cargo.toml

@@ -36,7 +36,7 @@ impl<T: fmt::Debug> Error for TrySendError<T> {}
 
 /// A handle to send messages to an actor's mailbox.
 pub struct Sender<T> {
-    sender: flume::Sender<T>,
+    sender: tokio::sync::mpsc::Sender<T>,
 }
 
 impl<T> Clone for Sender<T> {
@@ -53,9 +53,9 @@ impl<T> Sender<T> {
     /// Returns a `SendError` only if the receiving actor has terminated.
     pub async fn send(&mut self, message: T) -> Result<(), SendError<T>> {
         self.sender
-            .send_async(message)
+            .send(message)
             .await
-            .map_err(|flume::SendError(e)| SendError(e))
+            .map_err(|tokio::sync::mpsc::error::SendError(e)| SendError(e))
     }
 
     /// Attempts to immediately send a message.
@@ -64,27 +64,27 @@ impl<T> Sender<T> {
     /// receiving actor has terminated.
     pub fn try_send(&mut self, message: T) -> Result<(), TrySendError<T>> {
         self.sender.try_send(message).map_err(|e| match e {
-            flume::TrySendError::Full(e) => TrySendError::Full(e),
-            flume::TrySendError::Disconnected(e) => TrySendError::Closed(e),
+            tokio::sync::mpsc::error::TrySendError::Full(e) => TrySendError::Full(e),
+            tokio::sync::mpsc::error::TrySendError::Closed(e) => TrySendError::Closed(e),
         })
     }
 }
 
 /// An actor's mailbox for receiving messages.
 pub struct Receiver<T> {
-    receiver: flume::Receiver<T>,
+    receiver: tokio::sync::mpsc::Receiver<T>,
 }
 
 impl<T> Receiver<T> {
     /// Receives the next message from the mailbox.
     pub async fn recv(&mut self) -> Option<T> {
-        self.receiver.recv_async().await.ok()
+        self.receiver.recv().await
     }
 }
 
 /// Creates a new mailbox and a corresponding sender handle.
 pub fn new<T>(buffer: usize) -> (Sender<T>, Receiver<T>) {
-    let (sender, receiver) = flume::bounded(buffer);
+    let (sender, receiver) = tokio::sync::mpsc::channel(buffer);
     (Sender { sender }, Receiver { receiver })
 }