thespis_impl 0.3.0

Reference implementation for the thespis actor model
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

//! Showning how the futures produced by thespis can be run to completion on any thread.
//
use
{
	std               :: { thread               } ,
	thespis           :: { *                    } ,
	thespis_impl      :: { *                    } ,
	futures::executor :: { block_on, ThreadPool } ,
	std               :: { error::Error         } ,
};



#[ derive( Actor ) ]
//
struct MyActor;

struct Ping( String );


impl Message for Ping
{
	type Return = String;
}


impl Handler< Ping > for MyActor
{
	#[async_fn] fn handle( &mut self, _msg: Ping ) -> String
	{
		"pong".into()
	}
}


#[async_std::main]
//
async fn main() -> Result< (), Box<dyn Error> >
{
	let     exec = ThreadPool::new()?;
	let mut addr = Addr::builder( "my actor" ).spawn( MyActor, &exec )?;

	// call uses &mut self for Addr, so it's borrowed by the future. This means we can't just
	// move the future to another thread or spawn it directly. We have to move Addr with it.
	// This can be resolved by moving the Addr in an async block.
	//
	// let call = addr.call( Ping( "ping".into() ) );
	//
	let call = async move { addr.call( Ping( "ping".into() ) ).await };

	let handle = thread::spawn( move ||
	{
		block_on( async move
		{
			let result = call.await.expect( "Call failed" );

			assert_eq!( "pong".to_string(), result );
			dbg!( result );
		});
	});

	handle.join().unwrap();

	Ok(())
}