[hyperactor] assert_behaves!

Pull Request resolved: #1826

This adds a macro that asserts an actor's behavior; we use it to test the mesh behavior:

```
hyperactor::assert_behaves!(TestMeshController as Controller<TestMesh>);
```

It is implemented by statically validating that the actor type can bind to the defined behavior. This then provide a way to both document the intended behavior of an actor, and also to statically validate at the definition site that the behavior is implemented correctly.

(We already statically validate this at the *use* site, but then the errors are already "at a distance".)
ghstack-source-id: 323206574

Differential Revision: [D86786231](https://our.internmc.facebook.com/intern/diff/D86786231/)

**NOTE FOR REVIEWERS**: This PR has internal Meta-specific changes or comments, please review them on [Phabricator](https://our.internmc.facebook.com/intern/diff/D86786231/)!

Author: mariusae

hyperactor/src/actor.rs

@@ -727,6 +727,43 @@ pub trait Binds<A: Actor>: Referable {
 /// is handled by a specific actor type.
 pub trait RemoteHandles<M: RemoteMessage>: Referable {}
 
+/// Check if the actor behaves-as the a given behavior (defined by [`behavior!`]).
+///
+/// ```
+/// # use serde::Serialize;
+/// # use serde::Deserialize;
+/// # use hyperactor::Named;
+///
+/// // First, define a behavior, based on handling a single message type `()`.
+/// hyperactor::behavior!(UnitBehavior, ());
+///
+/// #[derive(hyperactor::Actor, Debug, Default)]
+/// struct MyActor;
+///
+/// #[async_trait::async_trait]
+/// impl hyperactor::Handler<()> for MyActor {
+///     async fn handle(
+///         &mut self,
+///         _cx: &hyperactor::Context<Self>,
+///         _message: (),
+///     ) -> Result<(), anyhow::Error> {
+///         // no-op
+///         Ok(())
+///     }
+/// }
+///
+/// hyperactor::assert_behaves!(MyActor as UnitBehavior);
+/// ```
+#[macro_export]
+macro_rules! assert_behaves {
+    ($ty:ty as $behavior:ty) => {
+        const _: fn() = || {
+            fn check<B: hyperactor::actor::Binds<$ty>>() {}
+            check::<$behavior>();
+        };
+    };
+}
+
 #[cfg(test)]
 mod tests {
     use std::sync::Mutex;

hyperactor_mesh/src/resource/mesh.rs

@@ -64,7 +64,6 @@ hyperactor::behavior!(
 #[cfg(test)]
 mod test {
     use hyperactor::Actor;
-    use hyperactor::ActorRef;
     use hyperactor::Context;
     use hyperactor::Handler;
 
@@ -114,14 +113,5 @@ mod test {
         _message: Stop => unimplemented!(),
     }
 
-    #[test]
-    fn test_controller_behavior() {
-        use hyperactor::ActorHandle;
-
-        // This is a compile-time check that TestMeshController implements
-        // the Controller<TestMesh> behavior correctly.
-        fn _assert_bind(handle: ActorHandle<TestMeshController>) -> ActorRef<Controller<TestMesh>> {
-            handle.bind()
-        }
-    }
+    hyperactor::assert_behaves!(TestMeshController as Controller<TestMesh>);
 }