interthread 2.0.2

Auto implementation of the 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
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

# interthread

The [`actor`](https://docs.rs/interthread/latest/interthread/attr.actor.html)  macro provided by this crate automates the implementation of an Actor Model for a given struct or enum. It handles the intricacies of message routing and synchronization, empowering developers to swiftly prototype the core functionality of their applications.
This fast sketching capability is
particularly useful when exploring different design options, 
experimenting with concurrency models, or implementing 
proof-of-concept systems. Not to mention, the cases where 
the importance of the program lies in the result of its work 
rather than its execution.

### Examples


Filename: Cargo.toml

```text
[dependencies]
interthread = "2.0.1"
oneshot     = "0.1.6" 
```

Filename: main.rs
```rust

pub struct MyActor {
    value: i8,
}

#[interthread::actor(show)] // <-  this is it 
impl MyActor {
    
    /// This is my comment
    pub fn new( v: i8 ) -> Self {
       Self { value: v } 
    }
    pub fn increment(&mut self) {
        self.value += 1;
    }
    pub fn add_number(&mut self, num: i8) -> i8 {
        self.value += num;
        self.value
    }
    pub fn get_value(&self) -> i8 {
        self.value
    }
}

// try hovering over model parts to see
// generated code as a comment
fn main() {

    let actor = MyActorLive::new(5);

    let mut actor_a = actor.clone();
    let mut actor_b = actor.clone();

    let handle_a = std::thread::spawn( move || { 
    actor_a.increment();
    });

    let handle_b = std::thread::spawn( move || {
    actor_b.add_number(5)
    });

    let _  = handle_a.join();
    let hb = handle_b.join().unwrap();

    // we never know which thread will
    // be first to call the actor so
    // hb = 10 or 11
    assert!(hb >= 10);

    assert_eq!(actor.get_value(), 11);
}

```
 Additionally, the `edit` option, when combined with the `file` option, facilitates writing the requested part of the generated code to the file. To substitute the macro with code on file, utilize `edit(file)` within the macro. 

The same example can be run in 
- [tokio](https://crates.io/crates/tokio)
- [async-std](https://crates.io/crates/async-std) 
- [smol](https://crates.io/crates/smol) 

with the only difference being that the methods will 
be marked as `async` and need to be `await`ed for 
asynchronous execution.