feat: implement Handler<M> API with envelope-based mailbox

Cargo.toml

@@ -15,6 +15,7 @@ members = [
     "examples/busy_genserver_warning",
     "examples/signal_test",
     "examples/signal_test_threads",
+    "examples/chat_room",
 ]
 
 [workspace.dependencies]

concurrency/src/error.rs

@@ -1,28 +1,20 @@
 #[derive(Debug, thiserror::Error)]
 pub enum ActorError {
-    #[error("Callback Error")]
-    Callback,
-    #[error("Initialization error")]
-    Initialization,
-    #[error("Server error")]
-    Server,
-    #[error("Unsupported Request on this Actor")]
-    RequestUnused,
-    #[error("Unsupported Message on this Actor")]
-    MessageUnused,
+    #[error("Actor stopped")]
+    ActorStopped,
     #[error("Request to Actor timed out")]
     RequestTimeout,
 }
 
 impl<T> From<spawned_rt::threads::mpsc::SendError<T>> for ActorError {
     fn from(_value: spawned_rt::threads::mpsc::SendError<T>) -> Self {
-        Self::Server
+        Self::ActorStopped
     }
 }
 
 impl<T> From<spawned_rt::tasks::mpsc::SendError<T>> for ActorError {
     fn from(_value: spawned_rt::tasks::mpsc::SendError<T>) -> Self {
-        Self::Server
+        Self::ActorStopped
     }
 }
 
@@ -32,7 +24,7 @@ mod tests {
 
     #[test]
     fn test_error_into_std_error() {
-        let error: &dyn std::error::Error = &ActorError::Callback;
-        assert_eq!(error.to_string(), "Callback Error");
+        let error: &dyn std::error::Error = &ActorError::ActorStopped;
+        assert_eq!(error.to_string(), "Actor stopped");
     }
 }

concurrency/src/lib.rs

@@ -1,6 +1,4 @@
-//! spawned concurrency
-//! Some basic traits and structs to implement concurrent code à-la-Erlang.
 pub mod error;
-pub mod messages;
+pub mod message;
 pub mod tasks;
 pub mod threads;

concurrency/src/message.rs

@@ -0,0 +1,52 @@
+pub trait Message: Send + 'static {
+    type Result: Send + 'static;
+}
+
+/// Declarative macro for defining message types.
+///
+/// Supports both unit structs and structs with fields, and they can be mixed
+/// in a single invocation:
+///
+/// ```ignore
+/// messages! {
+///     GetCount -> u64;
+///     Deposit { who: String, amount: i32 } -> Result<u64, BankError>;
+///     Stop -> ()
+/// }
+/// ```
+#[macro_export]
+macro_rules! messages {
+    () => {};
+
+    // Base: unit message
+    ($(#[$meta:meta])* $name:ident -> $result:ty) => {
+        $(#[$meta])*
+        #[derive(Debug)]
+        pub struct $name;
+        impl $crate::message::Message for $name {
+            type Result = $result;
+        }
+    };
+
+    // Base: struct message
+    ($(#[$meta:meta])* $name:ident { $($field:ident : $ftype:ty),* $(,)? } -> $result:ty) => {
+        $(#[$meta])*
+        #[derive(Debug)]
+        pub struct $name { $(pub $field: $ftype,)* }
+        impl $crate::message::Message for $name {
+            type Result = $result;
+        }
+    };
+
+    // Recursive: unit message followed by more
+    ($(#[$meta:meta])* $name:ident -> $result:ty; $($rest:tt)*) => {
+        $crate::messages!($(#[$meta])* $name -> $result);
+        $crate::messages!($($rest)*);
+    };
+
+    // Recursive: struct message followed by more
+    ($(#[$meta:meta])* $name:ident { $($field:ident : $ftype:ty),* $(,)? } -> $result:ty; $($rest:tt)*) => {
+        $crate::messages!($(#[$meta])* $name { $($field : $ftype),* } -> $result);
+        $crate::messages!($($rest)*);
+    };
+}