whichever 0.7.1

Implements a trait for an enum by forwarding to whichever variant it holds
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

#[whichever::dispatchable]
trait Apply {
    fn apply<F: Fn(u32) -> u32>(&self, f: F) -> u32;
    fn feed(&self, items: impl Iterator<Item = u32>) -> u32;
}

struct One;
struct Two;

impl Apply for One {
    fn apply<F: Fn(u32) -> u32>(&self, f: F) -> u32 {
        f(1)
    }
    fn feed(&self, items: impl Iterator<Item = u32>) -> u32 {
        items.sum()
    }
}

impl Apply for Two {
    fn apply<F: Fn(u32) -> u32>(&self, f: F) -> u32 {
        f(2)
    }
    fn feed(&self, items: impl Iterator<Item = u32>) -> u32 {
        items.count() as u32
    }
}

#[whichever::dispatch(Apply)]
enum Which {
    One(One),
    Two(Two),
}

#[test]
fn closures_and_argument_position_impl_trait_pass_through() {
    assert_eq!(Which::from(Two).apply(|x| x * 10), 20);
    assert_eq!(Which::from(One).feed([1, 2, 3].into_iter()), 6);
    assert_eq!(Which::from(Two).feed([1, 2, 3].into_iter()), 3);
}