Rust by Example

// `&'static str` is a reference to a string allocated in read only memory

author: &'static str,

title: &'static str,

year: u32,

}

// This function takes a reference to a book

fn borrow_book(book: &Book) {

println!("I immutably borrowed {} - {} edition", book.title, book.year);

}

// This function takes a reference to a mutable book and changes `year` to 2014

fn new_edition(book: &mut Book) {

book.year = 2014;

println!("I mutably borrowed {} - {} edition", book.title, book.year);

}

fn main() {

// Create an immutable Book named `immutabook`

let immutabook = Book {

// string literals have type `&'static str`

author: "Douglas Hofstadter",

title: "Gödel, Escher, Bach",

year: 1979,

};

// Create a mutable copy of `immutabook` and call it `mutabook`

let mut mutabook = immutabook;

// Immutably borrow an immutable object

borrow_book(&immutabook);

// Immutably borrow a mutable object

borrow_book(&mutabook);

// Borrow a mutable object as mutable

new_edition(&mut mutabook);

// Error! Cannot borrow an immutable object as mutable

new_edition(&mut immutabook);

// FIXME ^ Comment out this line

}

הההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההההה

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

See also:

static

Aliasing

Data can be immutably borrowed any number of times, but while immutably borrowed, the original data can't be mutably borrowed. On the other hand, only one mutable borrow is allowed at a time. The original data can be borrowed again only after the mutable reference has been used for the last time.

struct Point { x: i32, y: i32, z: i32 }

fn main() {

let mut point = Point { x: 0, y: 0, z: 0 };

let borrowed_point = &point

let another_borrow = &point

// Data can be accessed via the references and the original owner

println!("Point has coordinates: ({}, {}, {})",

borrowed_point.x, another_borrow.y, point.z);

// Error! Can't borrow `point` as mutable because it's currently

// borrowed as immutable.

// let mutable_borrow = &mut point;

// TODO ^ Try uncommenting this line

// The borrowed values are used again here

println!("Point has coordinates: ({}, {}, {})",

borrowed_point.x, another_borrow.y, point.z);

// The immutable references are no longer used for the rest of the code so

// it is possible to reborrow with a mutable reference.