ambassador 0.5.1

Trait implementation delegation via procedural macros
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

extern crate ambassador;

use ambassador::{delegatable_trait, Delegate};

#[delegatable_trait]
pub trait Shout {
    fn shout(&self) -> String;
}

#[delegatable_trait(inline = "no")]
pub trait Whisper {
    fn whisper(&self) -> String;
}

#[delegatable_trait(inline = "always")]
pub trait Sing {
    fn sing(&self) -> String;
}

#[delegatable_trait(inline = "never")]
pub trait Dance {
    fn dance(&self) -> String;
}

pub struct Cat;

impl Shout for Cat {
    fn shout(&self) -> String {
        "meow!".to_owned()
    }
}
impl Whisper for Cat {
    fn whisper(&self) -> String {
        "mew".to_owned()
    }
}
impl Sing for Cat {
    fn sing(&self) -> String {
        "la la".to_owned()
    }
}
impl Dance for Cat {
    fn dance(&self) -> String {
        "tap".to_owned()
    }
}

pub struct Dog;

impl Shout for Dog {
    fn shout(&self) -> String {
        "woof!".to_owned()
    }
}
impl Whisper for Dog {
    fn whisper(&self) -> String {
        "wrf".to_owned()
    }
}
impl Sing for Dog {
    fn sing(&self) -> String {
        "howl".to_owned()
    }
}
impl Dance for Dog {
    fn dance(&self) -> String {
        "spin".to_owned()
    }
}

// Default inline (yes) from trait, no override
#[derive(Delegate)]
#[delegate(Shout)]
pub enum Animals {
    Cat(Cat),
    Dog(Dog),
}

// Trait default is "no", but override to "always" at delegation site
#[derive(Delegate)]
#[delegate(Whisper, inline = "always")]
pub enum AnimalsWhisperOverride {
    Cat(Cat),
    Dog(Dog),
}

// Trait default is "always", use it
#[derive(Delegate)]
#[delegate(Sing)]
pub enum AnimalsSing {
    Cat(Cat),
    Dog(Dog),
}

// Trait default is "never", but override to "yes" at delegation site
#[derive(Delegate)]
#[delegate(Dance, inline = "yes")]
pub enum AnimalsDanceOverride {
    Cat(Cat),
    Dog(Dog),
}

// All four inline modes on delegate, with default trait (inline=yes)
#[derive(Delegate)]
#[delegate(Shout, inline = "yes")]
pub struct WrappedCatYes(Cat);

#[derive(Delegate)]
#[delegate(Shout, inline = "no")]
pub struct WrappedCatNo(Cat);

#[derive(Delegate)]
#[delegate(Shout, inline = "always")]
pub struct WrappedCatAlways(Cat);

#[derive(Delegate)]
#[delegate(Shout, inline = "never")]
pub struct WrappedCatNever(Cat);

// Use trait defaults without override (structs)
#[derive(Delegate)]
#[delegate(Whisper)]
pub struct WrappedCatWhisper(Cat);

#[derive(Delegate)]
#[delegate(Sing)]
pub struct WrappedCatSing(Cat);

#[derive(Delegate)]
#[delegate(Dance)]
pub struct WrappedCatDance(Cat);

pub fn main() {
    let a = Animals::Cat(Cat);
    assert_eq!(a.shout(), "meow!");

    let a = AnimalsWhisperOverride::Dog(Dog);
    assert_eq!(a.whisper(), "wrf");

    let a = AnimalsSing::Cat(Cat);
    assert_eq!(a.sing(), "la la");

    let a = AnimalsDanceOverride::Dog(Dog);
    assert_eq!(a.dance(), "spin");

    assert_eq!(WrappedCatYes(Cat).shout(), "meow!");
    assert_eq!(WrappedCatNo(Cat).shout(), "meow!");
    assert_eq!(WrappedCatAlways(Cat).shout(), "meow!");
    assert_eq!(WrappedCatNever(Cat).shout(), "meow!");

    assert_eq!(WrappedCatWhisper(Cat).whisper(), "mew");
    assert_eq!(WrappedCatSing(Cat).sing(), "la la");
    assert_eq!(WrappedCatDance(Cat).dance(), "tap");
}