Clone

When dealing with resources, the default behavior is to transfer them during assignments or function calls. However, sometimes we need to make a copy of the resource as well.

The Clone trait helps us do exactly this. Most commonly, we can use the .clone() method defined by the Clone trait.

1. // A unit struct without resources
2. #[derive(Debug, Clone, Copy)]
3. struct Nil;

5. // A tuple struct with resources that implements the `Clone` trait
6. #[derive(Clone, Debug)]
7. struct Pair(Box<i32>, Box<i32>);

9. fn main() {
10. // Instantiate `Nil`
11. let nil = Nil;
12. // Copy `Nil`, there are no resources to move
13. let copied_nil = nil;

15. // Both `Nil`s can be used independently
16. println!("original: {:?}", nil);
17. println!("copy: {:?}", copied_nil);

19. // Instantiate `Pair`
20. let pair = Pair(Box::new(1), Box::new(2));
21. println!("original: {:?}", pair);

23. // Copy `pair` into `moved_pair`, moves resources
24. let moved_pair = pair;
25. println!("copy: {:?}", moved_pair);

27. // Error! `pair` has lost its resources
28. //println!("original: {:?}", pair);
29. // TODO ^ Try uncommenting this line

31. // Clone `moved_pair` into `cloned_pair` (resources are included)
32. let cloned_pair = moved_pair.clone();
33. // Drop the original pair using std::mem::drop
34. drop(moved_pair);

36. // Error! `moved_pair` has been dropped
37. //println!("copy: {:?}", moved_pair);
38. // TODO ^ Try uncommenting this line

40. // The result from .clone() can still be used!
41. println!("clone: {:?}", cloned_pair);
42. }