use std::collections::HashMap;
// #[derive(Copy, Clone)]
enum SomeEnum {
Some1,
Some2,
}
struct SomeStruct {
pub some_enum: SomeEnum,
pub s: String,
}
fn proc_struct(some_struct: &SomeStruct) {
let mut map = HashMap::new();
map.insert(String::from("any"), 0);
match map.get(&some_struct.s) { // just to make a reference in SomeStruct
Some(v) => {
proc1(some_struct.some_enum);
proc2(&some_struct.some_enum);
}
None => {}
}
}
fn proc1(some: SomeEnum) {}
fn proc2(some: &SomeEnum) {}
fn main() {
let some_struct = SomeStruct { some_enum: SomeEnum::Some1, s: String::from("s") };
proc_struct(&some_struct);
}
The above code produces the following error:
error[E0507]: cannot move out of borrowed content
--> src/main.rs:20:19
|
20 | proc1(some_struct.some_enum);
| ^^^^^^^^^^^ cannot move out of borrowed content
When I add #[derive(Copy, Clone)]
to SomeEnum
, it compiles fine.
Should simple enums like SomeEnum
derive the Copy
trait?
Is there any difference in performance between functions proc1()
and proc2()
?
Citing the docs:
Generally speaking, if your type can implement
Copy
, it should.
Since your SomeEnum
has no composite variants (e.g. Vec
s or String
s), I recommend making it Copy
able. It appears that it is actually smaller than a reference to it:
use std::mem;
enum SomeEnum {
Some1,
Some2,
}
fn main() {
assert_eq!(1, mem::size_of::<SomeEnum>());
assert_eq!(8, mem::size_of::<&SomeEnum>());
}
Though I doubt that in this case you will be able to detect any difference in performance.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With