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
|
# What `#[derive(Unwrap)]` generates
When an enum is decorated with `#[derive(Unwrap)]`, for each variant `foo` in the enum, with fields `(a, b, c, ...)` a public instance method `unwrap_foo(self) -> (a, b, c, ...)` is generated.
If you don't want the `unwrap_foo` method generated for a variant, you can put the `#[unwrap(ignore)]` attribute on that variant.
If you want to treat a reference, you can put the `#[unwrap(ref)]` attribute on the enum declaration or that variant, then `unwrap_foo_ref(self) -> (&a, &b, &c, ...)` will be generated. You can also use mutable references by putting `#[unwrap(ref_mut)]`.
## Example usage
```rust
# use derive_more::Unwrap;
#
# #[derive(Debug, PartialEq)]
#[derive(Unwrap)]
#[unwrap(ref)]
enum Maybe<T> {
Just(T),
Nothing,
}
fn main() {
assert_eq!(Maybe::Just(1).unwrap_just(), 1);
// Panics if variants are different
// assert_eq!(Maybe::<()>::Nothing.unwrap_just(), /* panic */);
// assert_eq!(Maybe::Just(2).unwrap_nothing(), /* panic */);
assert_eq!((&Maybe::Just(42)).unwrap_just_ref(), &42);
}
```
### What is generated?
The derive in the above example code generates the following code:
```rust
# enum Maybe<T> {
# Just(T),
# Nothing,
# }
#
impl<T> Maybe<T> {
pub fn unwrap_nothing(self) -> () {
match self {
Maybe::Nothing => (),
_ => panic!(),
}
}
pub fn unwrap_nothing_ref(&self) -> () {
match self {
Maybe::Nothing => (),
_ => panic!(),
}
}
pub fn unwrap_just(self) -> T {
match self {
Maybe::Just(field_0) => field_0,
_ => panic!(),
}
}
pub fn unwrap_just_ref(&self) -> &T {
match self {
Maybe::Just(field_0) => field_0,
_ => panic!(),
}
}
}
```
|
