@@ -9,116 +9,124 @@ extern crate not_exhaustive_enough_helper;
9
9
use not_exhaustive_enough_helper:: { AnotherCrateEnum , AnotherCrateStruct , TPrivateField } ;
10
10
11
11
#[ non_exhaustive]
12
- pub enum E {
12
+ pub enum DefaultEnum {
13
13
First ,
14
14
Second ,
15
15
Third ,
16
16
}
17
17
18
18
#[ non_exhaustive]
19
- pub enum K {
19
+ pub enum DataEnum {
20
20
First ( String ) ,
21
21
Second ( u32 , u32 ) ,
22
- Third ( String )
22
+ Third ( String ) ,
23
23
}
24
24
25
- enum EF {
25
+ pub enum StructVariantEnum1 {
26
26
#[ non_exhaustive]
27
- V { a : i32 , b : i32 }
27
+ V { a : i32 , b : i32 } ,
28
28
}
29
29
30
- enum F {
30
+ pub enum StructVariantEnum2 {
31
31
#[ non_exhaustive]
32
- V { a : i32 , b : i32 } ,
33
- A { c : u32 }
32
+ V {
33
+ a : i32 ,
34
+ b : i32 ,
35
+ } ,
36
+ A {
37
+ c : u32 ,
38
+ } ,
34
39
}
35
40
36
41
#[ derive( Default ) ]
37
42
#[ non_exhaustive]
38
- pub struct S {
43
+ pub struct DefaultStruct {
39
44
pub a : i32 ,
40
45
pub b : i32 ,
41
46
pub c : i32 ,
42
47
}
43
48
44
49
#[ derive( Default ) ]
45
50
#[ non_exhaustive]
46
- pub struct T ( pub i32 , pub i32 , pub i32 ) ;
47
-
51
+ pub struct DefaultTuple ( pub i32 , pub i32 , pub i32 ) ;
48
52
49
53
fn main ( ) {
50
54
//////// Enum
51
55
52
- let e = E :: First ;
56
+ let default_enum = DefaultEnum :: First ;
53
57
54
- let ef = EF :: V { a : 1 , b : 2 } ;
58
+ let struct_variant_enum_1 = StructVariantEnum1 :: V { a : 1 , b : 2 } ;
55
59
56
- let f = F :: V { a : 1 , b : 2 } ;
60
+ let struct_variant_enum_2 = StructVariantEnum2 :: V { a : 1 , b : 2 } ;
57
61
58
- match e {
59
- E :: First => { } ,
60
- E :: Second => { } ,
62
+ match default_enum {
63
+ DefaultEnum :: First => { } ,
64
+ DefaultEnum :: Second => { } ,
61
65
_ => { } ,
62
66
}
63
67
64
- match ef {
65
- EF :: V { a : _, ..} => { }
68
+ match struct_variant_enum_1 {
69
+ StructVariantEnum1 :: V { a : _, .. } => { } ,
66
70
}
67
71
68
- if let F :: V { a : _, ..} = f { }
72
+ match struct_variant_enum_2 {
73
+ StructVariantEnum2 :: V { a : _, .. } => { } ,
74
+ _ => { } ,
75
+ }
69
76
70
77
//
78
+
71
79
let example = "Example" . to_string ( ) ;
72
- let k = K :: First ( example) ;
80
+ let data_enum = DataEnum :: First ( example) ;
73
81
74
- match k {
75
- K :: First ( ..) => { } ,
76
- K :: Second ( ..) => { } ,
82
+ match data_enum {
83
+ DataEnum :: First ( ..) => { } ,
84
+ DataEnum :: Second ( ..) => { } ,
77
85
_ => { } ,
78
86
}
79
87
80
88
//////// Struct
81
89
82
- let S { a : _, b : _, .. } = S :: default ( ) ;
90
+ let DefaultStruct { a : _, b : _, .. } = DefaultStruct :: default ( ) ;
83
91
84
- match S :: default ( ) {
85
- S { a : 42 , b : 21 , .. } => { } ,
86
- S { a : _, b : _, .. } => { } ,
92
+ match DefaultStruct :: default ( ) {
93
+ DefaultStruct { a : 42 , b : 21 , .. } => { } ,
94
+ DefaultStruct { a : _, b : _, .. } => { } ,
87
95
}
88
96
89
- if let S { a : 42 , b : _, .. } = S :: default ( ) { }
97
+ if let DefaultStruct { a : 42 , b : _, .. } = DefaultStruct :: default ( ) { }
90
98
91
- let v = vec ! [ S :: default ( ) ] ;
99
+ let v = vec ! [ DefaultStruct :: default ( ) ] ;
92
100
93
- for S { a : _, b : _, .. } in v { }
101
+ for DefaultStruct { a : _, b : _, .. } in v { }
94
102
95
- while let S { a : 42 , b : _, .. } = S :: default ( ) {
103
+ while let DefaultStruct { a : 42 , b : _, .. } = DefaultStruct :: default ( ) {
96
104
break ;
97
105
}
98
106
99
- pub fn take_s ( S { a, b, .. } : S ) -> ( i32 , i32 ) {
107
+ pub fn take_s ( DefaultStruct { a, b, .. } : DefaultStruct ) -> ( i32 , i32 ) {
100
108
( a, b)
101
109
}
102
110
103
111
//////// Tuple Struct
104
112
105
- let T { 0 : _ , 1 : _ , .. } = T :: default ( ) ;
113
+ let DefaultTuple { 0 : _ , 1 : _ , .. } = DefaultTuple :: default ( ) ;
106
114
107
- match T :: default ( ) {
108
- T { 0 : 42 , 1 : 21 , .. } => { } ,
109
- T { 0 : _, 1 : _, .. } => { } ,
115
+ match DefaultTuple :: default ( ) {
116
+ DefaultTuple { 0 : 42 , 1 : 21 , .. } => { } ,
117
+ DefaultTuple { 0 : _, 1 : _, .. } => { } ,
110
118
}
111
119
112
- if let T { 0 : 42 , 1 : _, .. } = T :: default ( ) { }
120
+ if let DefaultTuple { 0 : 42 , 1 : _, .. } = DefaultTuple :: default ( ) { }
113
121
114
- let v = vec ! [ T :: default ( ) ] ;
115
- for T { 0 : _, 1 : _, .. } in v { }
122
+ let default_tuple = vec ! [ DefaultTuple :: default ( ) ] ;
123
+ for DefaultTuple { 0 : _, 1 : _, .. } in default_tuple { }
116
124
117
- while let T { 0 : 42 , 1 : _, .. } = T :: default ( ) {
125
+ while let DefaultTuple { 0 : 42 , 1 : _, .. } = DefaultTuple :: default ( ) {
118
126
break ;
119
127
}
120
128
121
- pub fn take_t ( T { 0 : _ , 1 : _ , .. } : T ) -> ( i32 , i32 ) {
129
+ pub fn take_t ( DefaultTuple { 0 : _ , 1 : _ , .. } : DefaultTuple ) -> ( i32 , i32 ) {
122
130
( 0 , 1 )
123
131
}
124
132
@@ -132,8 +140,8 @@ fn main() {
132
140
}
133
141
134
142
match TPrivateField :: default ( ) {
135
- TPrivateField { 1 : 21 , .. } => { } ,
136
- _ => { }
143
+ TPrivateField { 1 : 21 , .. } => { } ,
144
+ _ => { } ,
137
145
}
138
146
139
147
if let TPrivateField { 0 : 42 , 1 : _, .. } = TPrivateField :: default ( ) { }
0 commit comments