Mutability

Mutable data can be mutably borrowed using &mut T. This is called a mutable reference and gives read/write access to the borrower. In contrast, &T borrows the data via an immutable reference, and the borrower can read the data but not modify it:

1. #[allow(dead_code)]
2. #[derive(Clone, Copy)]
3. struct Book {
4. // `&'static str` is a reference to a string allocated in read only memory
5. author: &'static str,
6. title: &'static str,
7. year: u32,
8. }

10. // This function takes a reference to a book
11. fn borrow_book(book: &Book) {
12. println!("I immutably borrowed {} - {} edition", book.title, book.year);
13. }

15. // This function takes a reference to a mutable book and changes `year` to 2014
16. fn new_edition(book: &mut Book) {
17. book.year = 2014;
18. println!("I mutably borrowed {} - {} edition", book.title, book.year);
19. }

21. fn main() {
22. // Create an immutable Book named `immutabook`
23. let immutabook = Book {
24. // string literals have type `&'static str`
25. author: "Douglas Hofstadter",
26. title: "Gödel, Escher, Bach",
27. year: 1979,
28. };

30. // Create a mutable copy of `immutabook` and call it `mutabook`
31. let mut mutabook = immutabook;

33. // Immutably borrow an immutable object
34. borrow_book(&immutabook);

36. // Immutably borrow a mutable object
37. borrow_book(&mutabook);

39. // Borrow a mutable object as mutable
40. new_edition(&mut mutabook);

42. // Error! Cannot borrow an immutable object as mutable
43. new_edition(&mut immutabook);
44. // FIXME ^ Comment out this line
45. }

See also:

static