Struct Link 

pub struct Link<A: ActorLike> { /* private fields */ }

Implementations

impl<A: ActorLike> Link<A>

pub fn new( tx: <A::Channel as ActorChannel>::Sender, token: CancelToken<A::Cancel>, state: A::State, ) -> Self

pub fn alive(&self) -> bool

pub fn wait(&self) -> BoxFuture<'_, ()>

pub fn state(&self) -> &A::State

impl<A: ActorLike> Link<A>

pub async fn ask_dyn_async<T>( &self, message: T, ) -> BoxFuture<'static, <A as Handler<T>>::Reply>

where T: SyncTrait, A: Handler<T> + ActorLike<Message = Multi<A>>,

pub async fn tell_dyn<T>(&self, message: T)

where T: SyncTrait, A: Handler<T> + ActorLike<Message = Multi<A>>,

pub async fn relay_dyn<T>( &self, envelope: Envelope<T, <A as Handler<T>>::Reply>, )

where T: SyncTrait, A: Handler<T> + ActorLike<Message = Multi<A>>,

pub async fn ask_dyn<T>(&self, message: T) -> <A as Handler<T>>::Reply

where T: SyncTrait, A: Handler<T> + ActorLike<Message = Multi<A>>,

Examples found in repository

examples/ping_pong.rs (line 59)

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: StartPing) -> Self::Reply {
        self.pong_actor = Some(msg.0);
        
        // Start the ping-pong game
        if let Some(ref pong) = self.pong_actor {
            self.ping_count += 1;
            println!("Ping #{}", self.ping_count);
            let _ = pong.ask_dyn(Ping(self.ping_count)).await;
        }
        
        Ok(())
    }
}

impl Handler<Pong> for PingActor {
    type Reply = Result<(), anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: Pong) -> Self::Reply {
        println!("Received Pong #{}", msg.0);
        
        // Continue ping-pong for a few rounds
        if self.ping_count < 5 {
            if let Some(ref pong) = self.pong_actor {
                self.ping_count += 1;
                println!("Ping #{}", self.ping_count);
                let _ = pong.ask_dyn(Ping(self.ping_count)).await;
            }
        } else {
            println!("Ping-pong game finished!");
        }
        
        Ok(())
    }
}

// Pong Actor implementation
impl Actor for PongActor {
    type Spec = ();
    type Message = Multi<Self>;
    type Channel = MpscChannel<Self::Message>;
    type Cancel = ();
    type State = ();

    fn state(_spec: &Self::Spec) -> Self::State {}

    fn init(_ctx: Init<'_, Self>) -> impl Future<Output = Result<Self, Self::Cancel>> + Send + 'static {
        async move {
            println!("PongActor initialized");
            Ok(PongActor { pong_count: 0 })
        }
    }
}

impl Handler<Ping> for PongActor {
    type Reply = Result<(), anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: Ping) -> Self::Reply {
        self.pong_count += 1;
        println!("Received Ping #{}, sending Pong #{}", msg.0, self.pong_count);
        
        // We need the ping actor reference to send back Pong
        // For this example, we'll use the actor context to get the sender
        Ok(())
    }
}

// Since we need bidirectional communication, let's modify the approach
#[derive(Debug)]
pub struct PingPong {
    other_actor: Option<Link<PingPong>>,
    is_ping: bool,
    count: u32,
}

#[derive(Debug)]
pub struct Connect(pub Link<PingPong>);

#[derive(Debug)]
pub struct Ball(pub u32);

impl Actor for PingPong {
    type Spec = bool; // true for ping, false for pong
    type Message = Multi<Self>;
    type Channel = MpscChannel<Self::Message>;
    type Cancel = ();
    type State = ();

    fn state(_spec: &Self::Spec) -> Self::State {}

    fn init(ctx: Init<'_, Self>) -> impl Future<Output = Result<Self, Self::Cancel>> + Send + 'static {
        let is_ping = ctx.spec;
        async move {
            let name = if is_ping { "Ping" } else { "Pong" };
            println!("{} actor initialized", name);
            Ok(PingPong {
                other_actor: None,
                is_ping,
                count: 0,
            })
        }
    }
}

impl Handler<Connect> for PingPong {
    type Reply = Result<(), anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: Connect) -> Self::Reply {
        self.other_actor = Some(msg.0);
        
        // If this is the ping actor, start the game
        if self.is_ping {
            if let Some(ref other) = self.other_actor {
                self.count = 1;
                println!("Ping sends ball #{}", self.count);
                let _ = other.ask_dyn(Ball(self.count)).await;
            }
        }
        
        Ok(())
    }
}

impl Handler<Ball> for PingPong {
    type Reply = Result<(), anyhow::Error>;

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: Ball) -> Self::Reply {
        let name = if self.is_ping { "Ping" } else { "Pong" };
        println!("{} receives ball #{}", name, msg.0);
        
        if msg.0 < 10 {
            if let Some(ref other) = self.other_actor {
                let next_count = msg.0 + 1;
                println!("{} sends ball #{}", name, next_count);
                let _ = other.ask_dyn(Ball(next_count)).await;
            }
        } else {
            println!("{} stops the game at ball #{}", name, msg.0);
        }
        
        Ok(())
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Spawn ping and pong actors
    let ping = spawn::<PingPong>(true);
    let pong = spawn::<PingPong>(false);

    // Connect them
    let _ = ping.ask_dyn(Connect(pong.clone())).await;
    let _ = pong.ask_dyn(Connect(ping)).await;

    // Wait for the game to finish
    sleep(Duration::from_secs(2)).await;

    Ok(())
}

examples/bank_account.rs (line 130)

    async fn handle(&mut self, _ctx: Call<'_, Self, Self::Reply>, msg: Transfer) -> Self::Reply {
        if msg.amount <= 0.0 {
            return Err(BankError::InvalidAmount { amount: msg.amount }.into());
        }

        if self.balance < msg.amount {
            return Err(BankError::InsufficientFunds { 
                balance: self.balance, 
                requested: msg.amount 
            }.into());
        }

        // Withdraw from this account
        self.balance -= msg.amount;
        println!("Account {}: Transfer out ${:.2}, new balance: ${:.2}", 
                 self.account_number, msg.amount, self.balance);

        // Deposit to target account
        let _ = msg.to_account.ask_dyn(Deposit { amount: msg.amount }).await?;
        println!("Transfer of ${:.2} completed from {} to target account", 
                 msg.amount, self.account_number);

        Ok(())
    }
}

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Create two bank accounts
    let alice_account = spawn::<BankAccount>(("ALICE-001".to_string(), 1000.0));
    let bob_account = spawn::<BankAccount>(("BOB-002".to_string(), 500.0));

    // Perform some operations
    println!("\n=== Initial Operations ===");
    
    // Check initial balances
    let alice_balance = alice_account.ask_dyn(GetBalance).await?;
    let bob_balance = bob_account.ask_dyn(GetBalance).await?;
    println!("Alice: ${:.2}, Bob: ${:.2}", alice_balance, bob_balance);

    // Alice deposits money
    let _ = alice_account.ask_dyn(Deposit { amount: 200.0 }).await?;

    // Bob withdraws money
    let _ = bob_account.ask_dyn(Withdraw { amount: 100.0 }).await?;

    println!("\n=== Transfer Operation ===");
    
    // Alice transfers money to Bob
    alice_account.ask_dyn(Transfer { 
        to_account: bob_account.clone(), 
        amount: 300.0 
    }).await?;

    println!("\n=== Final Balances ===");
    let alice_final = alice_account.ask_dyn(GetBalance).await?;
    let bob_final = bob_account.ask_dyn(GetBalance).await?;
    println!("Alice: ${:.2}, Bob: ${:.2}", alice_final, bob_final);

    println!("\n=== Error Handling ===");
    
    // Try to withdraw more than available (should fail)
    match alice_account.ask_dyn(Withdraw { amount: 2000.0 }).await {
        Ok(_) => println!("Withdrawal succeeded unexpectedly!"),
        Err(e) => println!("Withdrawal failed as expected: {}", e),
    }

    // Wait a moment before shutting down
    sleep(Duration::from_millis(100)).await;

    Ok(())
}

examples/handler_pattern.rs (line 105)

async fn main() -> anyhow::Result<()> {
    println!("=== Handler Pattern Example ===\n");

    // Spawn the actor
    let actor = spawn::<MultiHandlerActor>("CounterBot".to_string());

    // Use different message types with the same actor
    println!("1. Testing typed messages:");
    
    // Increment counter
    let count1: Result<i32, anyhow::Error> = actor.ask_dyn(IncrementMsg).await;
    println!("Result: {:?}", count1);

    let count2: Result<i32, anyhow::Error> = actor.ask_dyn(IncrementMsg).await;  
    println!("Result: {:?}", count2);

    // Get current count
    let current: Result<i32, anyhow::Error> = actor.ask_dyn(GetCountMsg).await;
    println!("Current count: {:?}", current);

    println!("\n2. Testing name operations:");
    
    // Change name
    let old_name: Result<String, anyhow::Error> = actor.ask_dyn(SetNameMsg("SuperBot".to_string())).await;
    println!("Previous name: {:?}", old_name);

    // Get current name
    let name: Result<String, anyhow::Error> = actor.ask_dyn(GetNameMsg).await;
    println!("Current name: {:?}", name);

    println!("\n3. Testing dynamic string messages:");
    
    // Send string messages dynamically
    let response1: Result<String, anyhow::Error> = actor.ask_dyn("Hello there!".to_string()).await;
    println!("Response: {:?}", response1);

    let response2: Result<String, anyhow::Error> = actor.ask_dyn("How are you doing?".to_string()).await;
    println!("Response: {:?}", response2);

    println!("\n4. Final state check:");
    let final_count: Result<i32, anyhow::Error> = actor.ask_dyn(GetCountMsg).await;
    let final_name: Result<String, anyhow::Error> = actor.ask_dyn(GetNameMsg).await;
    println!("Final count: {:?}, Final name: {:?}", final_count, final_name);

    Ok(())
}

examples/worker_pool.rs (line 130)

async fn main() -> anyhow::Result<()> {
    println!("=== Worker Pool Example ===\n");
    
    // Create workers
    let worker1 = spawn::<Worker>(1);
    let worker2 = spawn::<Worker>(2);
    let worker3 = spawn::<Worker>(3);
    
    // Submit several tasks to different workers
    println!("Submitting tasks...\n");
    
    let tasks = vec![
        ("Calculate prime numbers", 500),
        ("Process image", 800),
        ("Analyze data", 300),
        ("Generate report", 1000),
        ("Send email", 200),
        ("Update database", 600),
    ];
    
    // Submit tasks concurrently using tokio::spawn
    let mut handles = vec![];
    
    for (i, (task_name, duration)) in tasks.into_iter().enumerate() {
        let worker = match i % 3 {
            0 => worker1.clone(),
            1 => worker2.clone(),
            _ => worker3.clone(),
        };
        
        let handle = tokio::spawn(async move {
            let task = Task {
                id: (i + 1) as u32,
                data: format!("{} #{}", task_name, i + 1),
                processing_time_ms: duration,
            };
            
            worker.ask_dyn(task).await
        });
        handles.push(handle);
    }
    
    // Wait for all tasks to complete
    println!("Waiting for all tasks to complete...\n");
    for handle in handles {
        match handle.await? {
            Ok(result) => println!("✓ Task {} completed: {}", result.task_id, result.result),
            Err(e) => println!("✗ Task failed: {}", e),
        }
    }
    
    // Get worker statistics
    println!("\n=== Worker Statistics ===");
    for worker in [&worker1, &worker2, &worker3] {
        match worker.ask_dyn(GetWorkerStats).await {
            Ok(stats) => println!("Worker {}: {} tasks processed", stats.worker_id, stats.tasks_processed),
            Err(e) => println!("Failed to get stats: {}", e),
        }
    }
    
    println!("\n=== All tasks completed ===");
    
    // Wait a moment for any remaining output
    sleep(Duration::from_millis(500)).await;
    
    Ok(())
}

examples/dynamic_dispatch.rs (lines 186-189)

async fn main() -> anyhow::Result<()> {
    println!("=== Dynamic Dispatch Example ===\n");

    let router = spawn::<RouterActor>(());

    // Test typed message handlers
    println!("1. Setting up routes:");
    
    let _: Result<bool, anyhow::Error> = router.ask_dyn(AddRouteRequest {
        path: "/api/users".to_string(),
        handler: "UserHandler".to_string(),
    }).await;
    
    let _: Result<bool, anyhow::Error> = router.ask_dyn(AddRouteRequest {
        path: "/api/posts".to_string(), 
        handler: "PostHandler".to_string(),
    }).await;

    let _: Result<bool, anyhow::Error> = router.ask_dyn(AddRouteRequest {
        path: "/health".to_string(),
        handler: "HealthHandler".to_string(), 
    }).await;

    println!("\n2. Testing route lookups:");
    
    let response: Result<RouteResponse, anyhow::Error> = router.ask_dyn(GetRouteRequest {
        path: "/api/users".to_string(),
    }).await;
    println!("Lookup result: {:?}", response);

    let response: Result<RouteResponse, anyhow::Error> = router.ask_dyn(GetRouteRequest {
        path: "/nonexistent".to_string(),
    }).await;
    println!("Lookup result: {:?}", response);

    println!("\n3. Listing all routes:");
    let routes: Result<Vec<(String, String)>, anyhow::Error> = router.ask_dyn(ListRoutesRequest).await;
    println!("Routes: {:?}", routes);

    println!("\n4. Testing dynamic string commands:");
    
    let help: Result<String, anyhow::Error> = router.ask_dyn("help".to_string()).await;
    println!("Help response: {:?}", help);

    let status: Result<String, anyhow::Error> = router.ask_dyn("status".to_string()).await;
    println!("Status response: {:?}", status);

    let echo: Result<String, anyhow::Error> = router.ask_dyn("echo Hello dynamic world!".to_string()).await;
    println!("Echo response: {:?}", echo);

    let unknown: Result<String, anyhow::Error> = router.ask_dyn("unknown command".to_string()).await;
    println!("Unknown command response: {:?}", unknown);

    println!("\n5. Final stats:");
    let stats: Result<(u32, usize), anyhow::Error> = router.ask_dyn(StatsRequest).await;
    println!("Final stats: {:?}", stats);

    Ok(())
}

pub async fn send<T, R>(&self, message: T) -> R

where A: ActorLike<Message = Envelope<T, R>>, T: Send + Sync + 'static, R: Send + Sync + 'static + FromError<<<<A as ActorLike>::Channel as ActorChannel>::Sender as ActorSender<<<A as ActorLike>::Channel as ActorChannel>::Message>>::Error> + FromError<RecvError>,

Examples found in repository

examples/echo_server.rs (line 40)

async fn main() -> anyhow::Result<()> {
    let echo_server = spawn::<EchoServer>(());

    let messages = vec!["Hello", "World", "How are you?", "Goodbye"];

    for message in messages {
        let response: anyhow::Result<String> = echo_server.send(message.to_string()).await;
        println!("Received: {}", response?);
    }

    Ok(())
}

examples/basic_actor.rs (line 75)

async fn main() -> anyhow::Result<()> {
    // Spawn a counter actor with initial value 0
    let counter = spawn::<Counter>(0);

    // Send increment messages
    counter.send(()).await?;
    counter.send(()).await?;
    counter.send(()).await?;

    println!("Sent 3 increment messages");

    // For demonstration, we'll just show that we can increment
    // A real multi-message actor would use the Multi<A> pattern
    // as shown in the integration tests

    Ok(())
}

examples/simple_counter.rs (line 60)

async fn main() -> anyhow::Result<()> {
    // Spawn a counter actor with initial value 0
    let counter = spawn::<Counter>(0);

    // Send increment messages
    let _: anyhow::Result<CounterResponse> = counter.send(CounterRequest::Increment).await;
    let _: anyhow::Result<CounterResponse> = counter.send(CounterRequest::Increment).await;
    let _: anyhow::Result<CounterResponse> = counter.send(CounterRequest::Increment).await;

    // Get the current count
    let response: anyhow::Result<CounterResponse> = counter.send(CounterRequest::GetCount).await;
    match response? {
        CounterResponse::Count(count) => println!("Final count: {}", count),
        _ => println!("Unexpected response"),
    }

    Ok(())
}

pub async fn send_raw( &self, message: A::Message, ) -> Result<(), <<<A as ActorLike>::Channel as ActorChannel>::Sender as ActorSender<<<A as ActorLike>::Channel as ActorChannel>::Message>>::Error>

pub fn cancel(&self, reason: A::Cancel)

pub async fn cancel_and_wait(&self, reason: A::Cancel)

pub fn to_dyn<M>(&self) -> DynLink<M>

where M: Send + Sync + 'static, A: Handler<M> + ActorLike<Message = Multi<A>>,

impl<A: Actor> Link<A>

pub fn downgrade(&self) -> WeakLink<A>

Trait Implementations

impl<A: ActorLike> Clone for Link<A>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<A: ActorLike> Debug for Link<A>

where A::State: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A: ActorLike> Hash for Link<A>

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<A: ActorLike> PartialEq for Link<A>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A: ActorLike> Eq for Link<A>