feat!: relax request impls to be generic to any mailbox (#71)

* feat!: relax request impls to be generic to any mailbox

* feat: add generic implementation of TryMessageSendSync

src/actor/actor_ref.rs

@@ -770,7 +770,7 @@ impl<A: Actor> RemoteActorRef<A> {
     >
     where
         A: remote::RemoteActor + Message<M> + remote::RemoteMessage<M>,
-        M: serde::Serialize,
+        M: serde::Serialize + Send + 'static,
         <A::Reply as Reply>::Ok: for<'de> serde::Deserialize<'de>,
     {
         AskRequest::new_remote(self, msg)

src/actor/pool.rs

@@ -212,6 +212,7 @@ where
 pub enum WorkerReply<A, M>
 where
     A: Actor + Message<M>,
+    M: Send + 'static,
 {
     /// The message was forwarded to a worker.
     Forwarded,

src/mailbox.rs

@@ -30,6 +30,10 @@ pub trait Mailbox<A: Actor>: SignalMailbox + Clone + Send + Sync {
         &self,
         signal: Signal<A>,
     ) -> impl Future<Output = Result<(), SendError<Signal<A>, E>>> + Send + '_;
+    /// Tries to send a signal to the mailbox, failing if the mailbox is full.
+    fn try_send<E: 'static>(&self, signal: Signal<A>) -> Result<(), SendError<Signal<A>, E>>;
+    /// Sends a signal to the mailbox, blocking the current thread.
+    fn blocking_send<E: 'static>(&self, signal: Signal<A>) -> Result<(), SendError<Signal<A>, E>>;
     /// Waits for the mailbox to be closed.
     fn closed(&self) -> impl Future<Output = ()> + Send + '_;
     /// Checks if the mailbox is closed.

src/mailbox/bounded.rs

@@ -39,6 +39,16 @@ impl<A: Actor> Mailbox<A> for BoundedMailbox<A> {
         Ok(self.0.send(signal).await?)
     }
 
+    #[inline]
+    fn try_send<E: 'static>(&self, signal: Signal<A>) -> Result<(), SendError<Signal<A>, E>> {
+        Ok(self.0.try_send(signal)?)
+    }
+
+    #[inline]
+    fn blocking_send<E: 'static>(&self, signal: Signal<A>) -> Result<(), SendError<Signal<A>, E>> {
+        Ok(self.0.blocking_send(signal)?)
+    }
+
     #[inline]
     async fn closed(&self) {
         self.0.closed().await

src/mailbox/unbounded.rs

@@ -39,6 +39,16 @@ impl<A: Actor> Mailbox<A> for UnboundedMailbox<A> {
         Ok(self.0.send(signal)?)
     }
 
+    #[inline]
+    fn try_send<E: 'static>(&self, signal: Signal<A>) -> Result<(), SendError<Signal<A>, E>> {
+        Ok(self.0.send(signal)?)
+    }
+
+    #[inline]
+    fn blocking_send<E: 'static>(&self, signal: Signal<A>) -> Result<(), SendError<Signal<A>, E>> {
+        Ok(self.0.send(signal)?)
+    }
+
     #[inline]
     async fn closed(&self) {
         self.0.closed().await

src/message.rs

@@ -35,7 +35,7 @@ pub(crate) type BoxReply = Box<dyn any::Any + Send>;
 /// Messages are processed sequentially one at a time, with exclusive mutable access to the actors state.
 ///
 /// The reply type must implement [Reply].
-pub trait Message<T>: Actor {
+pub trait Message<T: Send + 'static>: Actor {
     /// The reply sent back to the message caller.
     type Reply: Reply;