Function spawn 

pub fn spawn<A: Actor>(spec: A::Spec) -> Link<A>

Spawn a new actor instance with the given specification.

This is a convenience function that delegates to the actor’s associated spawn method, providing a unified interface for actor creation.

Arguments

• spec - The specification required to initialize the actor

Returns

A Link<A> that can be used to send messages to the spawned actor.

Examples

use actor12::{spawn, Actor, Init, Exec, MpscChannel, Multi};

struct MyActor;

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

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

    fn init(_ctx: Init<'_, Self>) -> impl std::future::Future<Output = Result<Self, Self::Cancel>> + Send + 'static {
        std::future::ready(Ok(MyActor))
    }
}

// Spawn the actor
let link = spawn::<MyActor>(());

Examples found in repository

examples/echo_server.rs (line 35)

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/ping_pong.rs (line 198)

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/basic_actor.rs (line 72)

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 57)

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(())
}

examples/bank_account.rs (line 141)

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 99)

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(())
}

Additional examples can be found in:

• examples/worker_pool.rs
• examples/dynamic_dispatch.rs