RemoteActor -> Referable (#1435)

Summary:
Pull Request resolved: #1435

closing the loop on the `RemoteActor` thread in D83850739: rename `RemoteActor` -> `Referable` via `find fbcode/monarch -type f -exec sed -i -e 's/\bRemoteActor\b/Referable/g' {} +`.

Reviewed By: mariusae

Differential Revision: D83933787

fbshipit-source-id: be966446bbe7944648d00282d1ef9172a5897a55

Author: shayne-fletcher

docs/source/books/hyperactor-book/src/SUMMARY.md

@@ -35,7 +35,7 @@
   - [Handler](actors/handler.md)
   - [RemoteableActor](actors/remotable_actor.md)
   - [Checkpointable](actors/checkpointable.md)
-  - [RemoteActor](actors/remote_actor.md)
+  - [Referable](actors/remote_actor.md)
   - [Binds](actors/binds.md)
   - [RemoteHandles](actors/remote_handles.md)
   - [ActorHandle](actors/actor_handle.md)

docs/source/books/hyperactor-book/src/actors/actor_handle.md

@@ -108,7 +108,7 @@ pub fn bind<R: Binds<A>>(&self) -> ActorRef<R>
 ```
 This method requires that `R` implements the `Binds<A>` trait. The `Binds` trait specifies how to associate a remote-facing reference type with the concrete ports handled by the actor:
 ```rust
-pub trait Binds<A: Actor>: RemoteActor {
+pub trait Binds<A: Actor>: Referable {
     fn bind(ports: &Ports<A>);
 }
 ```

docs/source/books/hyperactor-book/src/actors/binds.md

@@ -2,7 +2,7 @@
 
 The `Binds` trait defines how an actor's ports are associated with the message types it can receive remotely.
 ```rust
-pub trait Binds<A: Actor>: RemoteActor {
+pub trait Binds<A: Actor>: Referable {
     fn bind(ports: &Ports<A>);
 }
 ```

docs/source/books/hyperactor-book/src/actors/index.md

@@ -10,7 +10,7 @@ This chapter introduces the actor system in hyperactor. We'll cover:
 - The [`Handler`](./handler.md) trait for defining message-handling behavior
 - The [`RemotableActor`](./remotable_actor.md) trait for enabling remote spawning
 - The [`Checkpointable`](./checkpointable.md) trait for supporting actor persistence and recovery
-- The [`RemoteActor`](./remote_actor.md) marker trait for remotely referencable types
+- The [`Referable`](./remote_actor.md) marker trait for remotely referencable types
 - The [`Binds`](./binds.md) trait for wiring exported ports to reference types
 - The [`RemoteHandles`](./remote_handles.md) trait for associating message types with a reference
 - The [`ActorHandle`](./actor_handle.md) type for referencing and communicating with running actors

docs/source/books/hyperactor-book/src/actors/remotable_actor.md

@@ -48,15 +48,15 @@ Returns a stable `TypeId` for the actor type. Used to identify actor types at ru
 ## Blanket Implementation
 
 The RemotableActor trait is automatically implemented for any actor type `A` that:
-- implements `Actor` and `RemoteActor`,
+- implements `Actor` and `Referable`,
 - and whose `Params` type implements `RemoteMessage`.
 
 This allows `A` to be remotely registered and instantiated from serialized data, typically via the runtime's registration mechanism.
 
 ```rust
 impl<A> RemotableActor for A
 where
-    A: Actor + RemoteActor,
+    A: Actor + Referable,
     A: Binds<A>,
     A::Params: RemoteMessage,
 {

docs/source/books/hyperactor-book/src/actors/remote_actor.md

@@ -1,7 +1,7 @@
-# RemoteActor
+# Referable
 
 ```rust
-pub trait RemoteActor: Named + Send + Sync {}
+pub trait Referable: Named + Send + Sync {}
 ```
 This is a marker trait indicating that a type is eligible to serve as a reference to a remote actor (i.e., an actor that may reside on a different proc).
 

docs/source/books/hyperactor-book/src/actors/remote_handles.md

@@ -1,8 +1,8 @@
 # RemoteHandles
 
-The `RemoteHandles<M>` trait is a marker used to declare that a given `RemoteActor` type can handle messages of type `M`.
+The `RemoteHandles<M>` trait is a marker used to declare that a given `Referable` type can handle messages of type `M`.
 ```rust
-pub trait RemoteHandles<M: RemoteMessage>: RemoteActor {}
+pub trait RemoteHandles<M: RemoteMessage>: Referable {}
 ```
 
 An implementation like:

docs/source/books/hyperactor-book/src/macros/alias.md

@@ -85,7 +85,7 @@ Expanding the example above yields a zero-sized façade actor with trait impls:
 ```rust
 pub struct ShoppingApi;
 
-impl hyperactor::actor::RemoteActor for ShoppingApi {}
+impl hyperactor::actor::Referable for ShoppingApi {}
 
 impl<A> hyperactor::actor::Binds<A> for ShoppingApi
 where

docs/source/books/hyperactor-book/src/macros/export.md

@@ -17,7 +17,7 @@ The macro expands to include:
  - A `Named` implementation for the actor
  - A `Binds<Self>` implementation that registers supported message types
  - Implementations of `RemoteHandles<T>` for each type in the `handlers = [...]` list
- - A `RemoteActor` marker implementation
+ - A `Referable` marker implementation
  - If `spawn = true`, a `RemotableActor` implementation and an inventory registration of the `spawn` function.
 
 This enables the actor to be:
@@ -27,7 +27,7 @@ This enables the actor to be:
 
 ## Generated Implementations (simplified)
 ```rust
-impl RemoteActor for ShoppingListActor {}
+impl Referable for ShoppingListActor {}
 
 impl RemoteHandles<ShoppingList> for ShoppingListActor {}
 impl RemoteHandles<Signal> for ShoppingListActor {}

docs/source/books/hyperactor-book/src/references/typed_refs.md

@@ -6,7 +6,7 @@ Typed references are strongly typed wrappers over raw identifiers like `ActorId`
 
 There are three main typed reference types:
 
-- [`ActorRef<A>`](#actorrefa): A typed reference to an actor implementing the `RemoteActor` trait.
+- [`ActorRef<A>`](#actorrefa): A typed reference to an actor implementing the `Referable` trait.
 - [`PortRef<M>`](#portrefm): A reference to a reusable mailbox port for messages of type `M` implementing the `RemoteMessage` trait.
 - [`OncePortRef<M>`](#onceportrefm): A reference to a one-shot port for receiving a single response of type `M` implementing the `RemoteMessage` trait.
 
@@ -16,7 +16,7 @@ These types are used as parameters in messages, return values from bindings, and
 
 ## `ActorRef<A>`
 
-`ActorRef<A>` is a typed reference to an actor of type `A`. It provides a way to identify and address remote actors that implement `RemoteActor`.
+`ActorRef<A>` is a typed reference to an actor of type `A`. It provides a way to identify and address remote actors that implement `Referable`.
 
 ```rust
 let actor_ref: ActorRef<MyActor> = ActorRef::attest(actor_id);
@@ -29,7 +29,7 @@ Unlike `ActorHandle<A>`, an `ActorRef` is just a reference — it doesn’t guar
 ### Definition
 ```rust
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
-pub struct ActorRef<A: RemoteActor> {
+pub struct ActorRef<A: Referable> {
     actor_id: ActorId,
     phantom: PhantomData<A>,
 }
@@ -80,7 +80,7 @@ Just like `PortRef`, this wraps a `PortId` with a phantom message type `M` for t
 
 ## `GangRef<A>`
 
-A `GangRef<A>` is a typed reference to a gang of actors, all of which implement the same `RemoteActor` type `A`.
+A `GangRef<A>` is a typed reference to a gang of actors, all of which implement the same `Referable` type `A`.
 ```rust
 let gang_ref: GangRef<MyActor> = GangId::new(...).into();
 ```
@@ -93,7 +93,7 @@ This allows you to route messages to specific members of a replicated actor grou
 ### Definition
 ```rust
 #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Hash, Ord)]
-pub struct GangRef<A: RemoteActor> {
+pub struct GangRef<A: Referable> {
     gang_id: GangId,
     phantom: PhantomData<A>,
 }