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(Traited1)]
#[enum_dispatch(Traited2)]
trait Trait {
    fn describe(&self) -> char;
}

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

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

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

#[enum_dispatch(Traited1, Traited2)]
trait TraitSingleLine {
    fn as_string(&self) -> String;
}

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

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

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

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

#[enum_dispatch]
pub enum Traited1 {
    A,
    B,
    C,
}

#[enum_dispatch]
pub enum Traited2 {
    A,
    B,
    C,
}

#[test]
fn main() {
    let a = Traited1::from(A);
    let b = Traited1::from(B);
    let c = Traited1::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 = Traited2::from(A);
    let b_sl = Traited2::from(B);
    let c_sl = Traited2::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());
}