enum_dispatch 0.3.13

Near drop-in replacement for dynamic-dispatched method calls with up to 10x the speed
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use core::convert::TryInto;
use enum_dispatch::enum_dispatch;

#[enum_dispatch]
trait Trait1 {
    fn describe(&self) -> char;
}

impl Trait1 for A {
    fn describe(&self) -> char {
        'A'
    }
}

impl Trait1 for B {
    fn describe(&self) -> char {
        'B'
    }
}

impl Trait1 for C {
    fn describe(&self) -> char {
        'C'
    }
}

#[enum_dispatch]
trait Trait2 {
    fn as_string(&self) -> String;
}

impl Trait2 for A {
    fn as_string(&self) -> String {
        "A".to_string()
    }
}

impl Trait2 for B {
    fn as_string(&self) -> String {
        " B ".to_string()
    }
}

impl Trait2 for C {
    fn as_string(&self) -> String {
        self.describe().to_string()
    }
}

pub struct A;
pub struct B;
pub struct C;

#[enum_dispatch(Trait1)]
#[enum_dispatch(Trait2)]
pub enum Traited {
    A,
    B,
    C,
}

#[enum_dispatch(Trait1, Trait2)]
pub enum TraitedSingleLine {
    A,
    B,
    C,
}

#[test]
fn main() {
    let a = Traited::from(A);
    let b = Traited::from(B);
    let c = Traited::from(C);

    assert_eq!(a.describe(), 'A');
    assert_eq!(b.describe(), 'B');
    assert_eq!(c.describe(), 'C');

    assert_eq!(a.as_string(), "A".to_string());
    assert_eq!(b.as_string(), " B ".to_string());
    assert_eq!(c.as_string(), "C".to_string());

    let b_from_c: Result<B, _> = c.try_into();
    assert!(b_from_c.is_err());
    assert_eq!(b_from_c.err().unwrap(), "Tried to convert variant C to B");

    let a_from_a: Result<A, _> = a.try_into();
    assert!(a_from_a.is_ok());

    let a_sl = TraitedSingleLine::from(A);
    let b_sl = TraitedSingleLine::from(B);
    let c_sl = TraitedSingleLine::from(C);

    assert_eq!(a_sl.describe(), 'A');
    assert_eq!(b_sl.describe(), 'B');
    assert_eq!(c_sl.describe(), 'C');

    assert_eq!(a_sl.as_string(), "A".to_string());
    assert_eq!(b_sl.as_string(), " B ".to_string());
    assert_eq!(c_sl.as_string(), "C".to_string());

    let b_from_c_sl: Result<B, _> = c_sl.try_into();
    assert!(b_from_c_sl.is_err());
    assert_eq!(
        b_from_c_sl.err().unwrap(),
        "Tried to convert variant C to B"
    );

    let a_from_a_sl: Result<A, _> = a_sl.try_into();
    assert!(a_from_a_sl.is_ok());
}