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
112
113
114
115
116
117
118
119

#![deny(late_bound_lifetime_arguments)]

use enum_dispatch::enum_dispatch;

pub struct S<'a, T>(std::marker::PhantomData<&'a T>);
pub trait Trait<'a> {}

#[enum_dispatch]
pub trait FooAPI {
    fn foo_warn<'a>(&mut self) -> &'a u32 {
        unimplemented!()
    }

    fn foo_err<'a, 'b>(&'a self, x: &'b u32) -> &'b u32 {
        x
    }

    // have late bound parameters
    fn e1<'a>(&self) {}
    fn e2(&self, _e: &()) {}
    fn e3(&self, _e: &()) -> &() {
        unimplemented!()
    }
    fn e4<'a>(&self, _e: &'a ()) -> &'a () {
        unimplemented!()
    }
    fn e5(&self) {}
    fn e6(&mut self) {}
    fn e7<'a, 'b>(&self) {}
    fn e8<'a>(&self, _t: &'a ()) {}
    fn e9<'a>(&self, _t: &()) -> &'a () {
        unimplemented!()
    }
    fn e10<'a>(&self, _t: &mut ()) -> &'a () {
        unimplemented!()
    }
    fn e11<'a>(&self, _t: &mut ()) -> &'a mut () {
        unimplemented!()
    }
    fn e12<'a>(&self, _t: ()) -> &'static mut () {
        unimplemented!()
    }
    fn e13<'a>(&self, _t: &'a S<'static, ()>) -> &'static () {
        unimplemented!()
    }
    fn e14<'a>(&self, _t: &'static S<'a, ()>) -> &'static () {
        unimplemented!()
    }
    fn e15<'a>(&self, _t: &'a S<'static, ()>) -> &'a () {
        unimplemented!()
    }
    fn e16<'a>(&self, _t: &'a S<'a, ()>) -> &'static () {
        unimplemented!()
    }
    fn e17<'a, 'b, 'c, T: Trait<'b>>(&self) {}
    fn e18<'a, 'b, T: Trait<'b>>(&self) {}
    fn e19<'a, 'b, T: Trait<'b>, F>(&self, _e: F)
    where
        F: for<'d, 'c> FnOnce(),
    {
    }

    // have no late bound parameters
    fn e20(&self) {}
    fn e21<'a>(&self) -> &'a () {
        unimplemented!()
    }
    fn e22<'a>(&self, _t: ()) -> &'a () {
        unimplemented!()
    }
    fn e23<'a>(&self, _e: &'static ()) -> &'a () {
        unimplemented!()
    }
    fn e24(&self, _t: ()) -> &'static () {
        unimplemented!()
    }
    fn e25(&self, _t: &'static ()) -> &'static () {
        unimplemented!()
    }
    fn e26(&self, _t: &'static S<()>) -> &'static () {
        unimplemented!()
    }
    fn e27(&self, _t: &'static S<'static, ()>) -> &'static () {
        unimplemented!()
    }
    fn e28<'a>(&self, _t: &'static S<'static, ()>) -> &'a () {
        unimplemented!()
    }
    fn e29<'b, T: Trait<'b>>(&self) {}
    fn e30<'b, T: Trait<'b>, F>(&self, _e: F)
    where
        F: for<'d, 'c> FnOnce(),
    {
    }
    fn e31<'b, T: Trait<'b>, F>(&self, _e: F)
    where
        F: for<'d, 'c> FnOnce(&'b ()),
    {
    }
    fn e32<'b, F>(&self, _e: F)
    where
        F: for<'d, 'c> FnOnce(&'b ()),
    {
    }
}

#[enum_dispatch(FooAPI)]
pub enum Foo {
    Something,
}

pub struct Something(u32);

impl FooAPI for Something {}

#[test]
fn main() {
    assert_eq!(*Something(2).foo_err(&8), 8);
}