The ref pattern

When doing pattern matching or destructuring via the let binding, the ref keyword can be used to take references to the fields of a struct/tuple. The example below shows a few instances where this can be useful:

1. #[derive(Clone, Copy)]
2. struct Point { x: i32, y: i32 }

4. fn main() {
5. let c = 'Q';

7. // A `ref` borrow on the left side of an assignment is equivalent to
8. // an `&` borrow on the right side.
9. let ref ref_c1 = c;
10. let ref_c2 = &c;

12. println!("ref_c1 equals ref_c2: {}", *ref_c1 == *ref_c2);

14. let point = Point { x: 0, y: 0 };

16. // `ref` is also valid when destructuring a struct.
17. let _copy_of_x = {
18. // `ref_to_x` is a reference to the `x` field of `point`.
19. let Point { x: ref ref_to_x, y: _ } = point;

21. // Return a copy of the `x` field of `point`.
22. *ref_to_x
23. };

25. // A mutable copy of `point`
26. let mut mutable_point = point;

28. {
29. // `ref` can be paired with `mut` to take mutable references.
30. let Point { x: _, y: ref mut mut_ref_to_y } = mutable_point;

32. // Mutate the `y` field of `mutable_point` via a mutable reference.
33. *mut_ref_to_y = 1;
34. }

36. println!("point is ({}, {})", point.x, point.y);
37. println!("mutable_point is ({}, {})", mutable_point.x, mutable_point.y);

39. // A mutable tuple that includes a pointer
40. let mut mutable_tuple = (Box::new(5u32), 3u32);

42. {
43. // Destructure `mutable_tuple` to change the value of `last`.
44. let (_, ref mut last) = mutable_tuple;
45. *last = 2u32;
46. }

48. println!("tuple is {:?}", mutable_tuple);
49. }