multicall 0.1.4

Macro to simplify multiple operations or calls on a single object
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

use multicall::multicall;

#[derive(Debug)]
struct Test {
    a: u32,
    b: i32,
    c: u8,
    greeting: String,
    to_greet: String,
}

impl Test {
    fn print_a(&self) {
        println!("{}", self.a);
    }
    fn print_b(&self) {
        println!("{}", self.b);
    }
    fn set_greeting(&mut self, greeting: &str) {
        self.greeting = greeting.to_owned();
    }
    fn set_to_greet(&mut self, to_greet: &str) {
        self.to_greet = to_greet.to_owned();
    }

    fn to_string(&self) -> String {
        multicall! {
            self:
            exec return format!(
                "{}, {}! Have some stuff: {}, {}, {}",
                #.greeting,
                #.to_greet,
                #.a,
                #.b,
                #.c,
            );
        }
    }
}

fn main() {
    let mut test = Test { a: 0, b: 0, c: 0, greeting: "Hello".to_owned(), to_greet: "Nobody".to_owned() };
    let mut value = 5;
    multicall! {
        &mut test:
        a = value;
        b = (#.a + value) as i32;
        print_a();
        print_b();
        exec println!("{}", #.to_string());
        c = 48;
        set_greeting("Hello");
        set_to_greet("multicall");
        exec println!("{}", #.to_string());
        set value = c as u32;
    }
    println!("{}", value);
}