type_dispatch 0.0.0

Utilities for dispatching functions, constants, and trait implementations based on types.
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
120
121
122
123
124
125
126
127
128
129
130
131
132

use type_dispatch_macros::{dispatch_const, impl_dispatch};

trait ApplyFilter<M> {
    fn apply(medium: &mut M);
}

struct GaussianBlur;
struct Fisheye;
struct Pixelate;

#[derive(Default)]
struct Painting {
    strokes: Vec<u64>,
}
#[derive(Default)]
struct Photoshop {
    pixels: Vec<Vec<u64>>,
}
#[derive(Default)]
struct Illustrator {
    vectors: Vec<(u64, u64)>,
}

// Implement individual filters manually as their implementations vary widely.
impl ApplyFilter<Painting> for GaussianBlur {
    fn apply(medium: &mut Painting) {
        medium.strokes.iter_mut().for_each(|stroke| *stroke *= 2);
    }
}
impl ApplyFilter<Photoshop> for GaussianBlur {
    fn apply(medium: &mut Photoshop) {
        medium
            .pixels
            .iter_mut()
            .for_each(|pixels| pixels.iter_mut().for_each(|pixel| *pixel *= 2));
    }
}
impl ApplyFilter<Illustrator> for GaussianBlur {
    fn apply(medium: &mut Illustrator) {
        medium
            .vectors
            .iter_mut()
            .for_each(|vector| *vector = (2 * vector.0, 2 * vector.1));
    }
}
impl ApplyFilter<Painting> for Fisheye {
    fn apply(medium: &mut Painting) {
        medium.strokes.iter_mut().for_each(|stroke| *stroke += 2);
    }
}
impl ApplyFilter<Photoshop> for Fisheye {
    fn apply(medium: &mut Photoshop) {
        medium
            .pixels
            .iter_mut()
            .for_each(|pixels| pixels.iter_mut().for_each(|pixel| *pixel += 2));
    }
}
impl ApplyFilter<Illustrator> for Fisheye {
    fn apply(medium: &mut Illustrator) {
        medium
            .vectors
            .iter_mut()
            .for_each(|vector| *vector = (vector.0 + 2, vector.1 + 2));
    }
}
impl ApplyFilter<Photoshop> for Pixelate {
    fn apply(medium: &mut Photoshop) {
        medium
            .pixels
            .iter_mut()
            .for_each(|pixels| pixels.iter_mut().for_each(|pixel| *pixel /= 2));
    }
}

struct StarryNight;

impl ApplyFilter<Painting> for StarryNight {
    fn apply(medium: &mut Painting) {
        medium.strokes.extend(vec![1, 2, 3, 4, 5]);
    }
}
impl ApplyFilter<Photoshop> for StarryNight {
    fn apply(medium: &mut Photoshop) {
        medium.pixels.extend(vec![vec![1, 2], vec![3, 4]]);
    }
}
impl ApplyFilter<Illustrator> for StarryNight {
    fn apply(medium: &mut Illustrator) {
        medium.vectors.extend(vec![(1, 2), (3, 4)]);
    }
}

struct RetroStarryNight;

// Use `impl_dispatch` to reuse similar code between two "media".
#[impl_dispatch({Painting; Illustrator})]
impl<M> ApplyFilter<M> for RetroStarryNight {
    fn apply(medium: &mut M) {
        StarryNight::apply(medium);
        Fisheye::apply(medium);
        for _ in 0..dispatch_const!(
            match M {
                Painting => 2: u64,
                Illustrator => 3: usize,
            }
        ) {
            GaussianBlur::apply(medium);
        }
    }
}
impl ApplyFilter<Photoshop> for RetroStarryNight {
    fn apply(medium: &mut Photoshop) {
        StarryNight::apply(medium);
        Pixelate::apply(medium);
    }
}

#[test]
fn impl_dispatch_works() {
    let mut painting = Painting::default();
    let mut photoshop = Photoshop::default();
    let mut illustrator = Illustrator::default();

    RetroStarryNight::apply(&mut painting);
    RetroStarryNight::apply(&mut photoshop);
    RetroStarryNight::apply(&mut illustrator);

    assert_eq!(painting.strokes, vec![12, 16, 20, 24, 28]);
    assert_eq!(photoshop.pixels, vec![vec![0, 1], vec![1, 2]]);
    assert_eq!(illustrator.vectors, vec![(24, 32), (40, 48)]);
}