Introduction to Borrowing and References

Borrowing is one of Rust's most distinctive and powerful features. It allows you to access data without taking ownership, enabling multiple parts of your code to work with the same data safely. The borrowing system, enforced by the compiler, prevents data races and dangling references at compile time.

Key Concepts

• References: Pointers that borrow values without owning them
• Borrowing: The act of creating references to data
• Lifetimes: How long references are valid
• Borrowing Rules: At any time, you can have either:
• One mutable reference
• Any number of immutable references
• No Dangling References: The compiler ensures references always point to valid data

1. Basic References

Immutable References

fn main() { let s = String::from("hello"); // Create an immutable reference (borrow) let r1 = &s; let r2 = &s; // Multiple immutable references are allowed println!("r1: {}, r2: {}", r1, r2); // References are dereferenced automatically in many contexts let len = r1.len(); // No need for (*r1).len() println!("Length: {}", len); // Function that takes a reference print_string(&s); // s is still usable here println!("Original: {}", s); } fn print_string(s: &String) { println!("Borrowed: {}", s); }

Mutable References

fn main() { let mut s = String::from("hello"); // Create a mutable reference let r = &mut s; // Modify through the mutable reference r.push_str(", world"); println!("r: {}", r); // Can't use s while r is active // println!("{}", s); // Error: cannot borrow as immutable // After r goes out of scope, s can be used again println!("s: {}", s); // Now OK // Multiple mutable references not allowed let mut t = String::from("test"); let r1 = &mut t; // let r2 = &mut t; // Error: cannot borrow as mutable more than once // But we can create new mutable reference after previous is done let r1 = &mut t; r1.push_str("1"); // r1 goes out of scope here let r2 = &mut t; // This is fine r2.push_str("2"); println!("t: {}", t); }

Reference Rules Demonstration

fn main() { let mut data = String::from("data"); // Rule 1: Many immutable references allowed let immut1 = &data; let immut2 = &data; println!("immut1: {}, immut2: {}", immut1, immut2); // immut1 and immut2 go out of scope here // Now we can have a mutable reference let mut_ref = &mut data; mut_ref.push_str(" modified"); println!("mut_ref: {}", mut_ref); // mut_ref goes out of scope // Can't mix mutable and immutable let immut = &data; // let mut_ref = &mut data; // Error: cannot borrow as mutable println!("immut: {}", immut); // Scope matters: references are valid until last use let mut s = String::from("hello"); let r1 = &s; let r2 = &s; println!("r1: {}, r2: {}", r1, r2); // r1 and r2 no longer used after this line let r3 = &mut s; // This is allowed r3.push_str(" world"); println!("r3: {}", r3); }

2. Borrowing in Functions

Function Parameters with References

// Function that borrows immutably fn calculate_length(s: &String) -> usize { s.len() } // s goes out of scope, but since it was borrowed, nothing happens // Function that borrows mutably fn modify_string(s: &mut String) { s.push_str(" - modified"); } // Function that borrows multiple parameters fn compare_strings(s1: &String, s2: &String) -> bool { s1 == s2 } // Function returning a reference (requires lifetime annotation) fn first_word(s: &str) -> &str { let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } } &s[..] } fn main() { let mut s1 = String::from("hello"); let s2 = String::from("world"); // Immutable borrow let len = calculate_length(&s1); println!("Length of '{}': {}", s1, len); // Mutable borrow modify_string(&mut s1); println!("Modified: {}", s1); // Multiple borrows let are_equal = compare_strings(&s1, &s2); println!("Equal: {}", are_equal); // Returning reference let sentence = String::from("hello world"); let word = first_word(&sentence); println!("First word: {}", word); }

Borrowing and Ownership Transfer

fn take_ownership(s: String) { println!("Took ownership of: {}", s); } // s dropped here fn borrow(s: &String) { println!("Borrowed: {}", s); } fn borrow_and_modify(s: &mut String) { s.push_str("!"); } fn give_ownership() -> String { let s = String::from("new string"); s // Ownership transferred out } fn main() { let s1 = String::from("hello"); // Borrowing doesn't transfer ownership borrow(&s1); println!("Still have s1: {}", s1); // After taking ownership, can't use take_ownership(s1); // println!("{}", s1); // Error: s1 moved // Get ownership back let s2 = give_ownership(); println!("Got: {}", s2); // Mutable borrow let mut s3 = String::from("rust"); borrow_and_modify(&mut s3); println!("After modify: {}", s3); }

3. Dereferencing

Explicit Dereferencing

fn main() { let x = 5; let y = &x; // Dereference to get the value assert_eq!(5, x); assert_eq!(5, *y); // With mutable references let mut z = 10; let w = &mut z; *w += 5; // Modify through dereference println!("z after modification: {}", z); // Dereferencing complex types let s = String::from("hello"); let r = &s; // These are equivalent: println!("Length: {}", (*r).len()); println!("Length: {}", r.len()); // Auto-dereferencing // Dereferencing in patterns let maybe_ref = Some(&5); match maybe_ref { Some(&value) => println!("Got value: {}", value), None => (), } // Equivalent using deref in pattern match maybe_ref { Some(value) => println!("Got ref to: {}", value), None => (), } }

Auto-dereferencing Rules

struct Point { x: i32, y: i32, } impl Point { fn distance_from_origin(&self) -> f64 { ((self.x.pow(2) + self.y.pow(2)) as f64).sqrt() } } fn main() { let p = Point { x: 3, y: 4 }; let r = &p; let rr = &&p; let rrr = &&&p; // All work due to auto-dereferencing println!("r distance: {}", r.distance_from_origin()); println!("rr distance: {}", rr.distance_from_origin()); println!("rrr distance: {}", rrr.distance_from_origin()); // With mutable references let mut v = vec![1, 2, 3]; let mut_ref = &mut v; // push automatically dereferences mut_ref.push(4); println!("mut_ref: {:?}", mut_ref); // Indexing also auto-derefs println!("First element: {}", mut_ref[0]); // Method calls auto-deref to find the right implementation let s = String::from("hello"); let r1 = &s; let r2 = &r1; let r3 = &r2; // All work - Rust automatically dereferences as needed println!("r1 len: {}", r1.len()); println!("r2 len: {}", r2.len()); println!("r3 len: {}", r3.len()); }

4. Reference Types and Coercions

String References and Slices

fn main() { // &String vs &str let s = String::from("hello"); let string_ref: &String = &s; let str_slice: &str = &s[..]; // Explicit conversion // &String coerces to &str automatically (deref coercion) fn takes_str(s: &str) { println!("Got: {}", s); } takes_str(&s); // &String coerced to &str takes_str("literal"); // Works directly with &str // Array references and slices let arr = [1, 2, 3, 4, 5]; let array_ref: &[i32; 5] = &arr; let slice: &[i32] = &arr[1..4]; println!("Array ref: {:?}", array_ref); println!("Slice: {:?}", slice); // Vector references let v = vec![1, 2, 3]; let vec_ref: &Vec<i32> = &v; let vec_slice: &[i32] = &v[..]; println!("Vec ref: {:?}", vec_ref); println!("Vec slice: {:?}", vec_slice); }

Reference to Trait Objects

trait Drawable { fn draw(&self); } struct Circle { radius: f64, } impl Drawable for Circle { fn draw(&self) { println!("Drawing circle with radius {}", self.radius); } } struct Square { side: f64, } impl Drawable for Square { fn draw(&self) { println!("Drawing square with side {}", self.side); } } fn draw_shape(shape: &dyn Drawable) { shape.draw(); } fn main() { let circle = Circle { radius: 5.0 }; let square = Square { side: 3.0 }; // References to trait objects let drawables: [&dyn Drawable; 2] = [&circle, &square]; for drawable in drawables { drawable.draw(); } // Function taking trait object reference draw_shape(&circle); draw_shape(&square); // Boxed trait objects let boxed: Box<dyn Drawable> = Box::new(Circle { radius: 10.0 }); boxed.draw(); }

5. Reference Patterns

Reference Patterns in Match

fn main() { // Matching on references let maybe_value: Option<i32> = Some(5); let ref_to_option = &maybe_value; match ref_to_option { Some(value) => println!("Got value: {}", value), None => println!("Got none"), } // Using ref keyword in patterns let x = 5; let y = Some(x); match y { Some(ref value) => println!("Got ref to: {}", value), // value is &i32 None => (), } // ref mut for mutable references let mut z = Some(10); match z { Some(ref mut value) => { *value += 5; println!("Modified: {}", value); } None => (), } println!("z after: {:?}", z); // Matching on slices let arr = [1, 2, 3]; let slice = &arr[..]; match slice { [first, second, third] => println!("Three elements: {}, {}, {}", first, second, third), [first, ..] => println!("First element: {}", first), [] => println!("Empty slice"), } // Matching on strings let s = String::from("hello"); let s_ref = &s; match s_ref { s if s.starts_with('h') => println!("Starts with h: {}", s), _ => println!("Other"), } }

Reference Patterns in Destructuring

struct Point { x: i32, y: i32, } fn main() { let point = Point { x: 10, y: 20 }; let point_ref = &point; // Destructuring a reference let Point { x, y } = point_ref; println!("x: {}, y: {}", x, y); // x and y are &i32 // Using & in pattern to match references let &Point { x: x_val, y: y_val } = point_ref; println!("x_val: {}, y_val: {}", x_val, y_val); // x_val and y_val are i32 // With nested references let nested = (1, &point); match nested { (num, Point { x, y }) => { println!("num: {}, x: {}, y: {}", num, x, y); } } // Mutable references in destructuring let mut point = Point { x: 5, y: 10 }; let point_mut_ref = &mut point; let Point { x, y } = point_mut_ref; *x += 1; *y += 2; println!("point after: ({}, {})", point.x, point.y); }

6. Borrowing and Lifetimes

Basic Lifetime Annotations

// Lifetime annotations specify relationship between references fn longest<'a>(x: &'a str, y: &'a str) -> &'a str { if x.len() > y.len() { x } else { y } } // Multiple lifetimes fn complex<'a, 'b>(x: &'a str, y: &'b str) -> &'a str { println!("y: {}", y); x // Return x with lifetime 'a } // Lifetime in struct struct ImportantExcerpt<'a> { part: &'a str, } impl<'a> ImportantExcerpt<'a> { fn level(&self) -> i32 { 3 } fn announce_and_return_part(&self, announcement: &str) -> &str { println!("Attention: {}", announcement); self.part // Lifetime elided - same as self } } fn main() { let string1 = String::from("long string is long"); let result; { let string2 = String::from("xyz"); result = longest(&string1, &string2); println!("Longest: {}", result); // Valid here } // string2 dropped // println!("Longest: {}", result); // Would be invalid if used let excerpt; { let novel = String::from("Call me Ishmael. Some years ago..."); excerpt = ImportantExcerpt { part: &novel[..20], }; println!("Excerpt: {}", excerpt.part); } // novel dropped, excerpt invalid after this // println!("{:?}", excerpt.part); // Error: borrowed value doesn't live long enough }

Lifetime Elision Rules

// No explicit lifetimes needed - elision rules apply // Rule 1: Each parameter that is a reference gets its own lifetime parameter fn first_word(s: &str) -> &str { // Elided: <'a>(s: &'a str) -> &'a str let bytes = s.as_bytes(); for (i, &item) in bytes.iter().enumerate() { if item == b' ' { return &s[0..i]; } } &s[..] } // Rule 2: If there's exactly one input lifetime, it's assigned to all output lifetimes fn identity(x: &i32) -> &i32 { // Elided: <'a>(x: &'a i32) -> &'a i32 x } // Rule 3: If there are multiple input lifetimes, but one is &self or &mut self, // the lifetime of self is assigned to all output lifetimes struct Container { data: String, } impl Container { fn get_data(&self) -> &str { // Elided: <'a>(&'a self) -> &'a str &self.data } fn process(&self, other: &str) -> &str { // Elided: <'a>(&'a self, other: &str) -> &'a str if other.len() > self.data.len() { other // But wait, this doesn't work with elision! } else { &self.data } } // The above doesn't actually work because the elided lifetime would // force both return values to have lifetime 'a, but 'other' has a different lifetime // Correct version: fn process_fixed<'a>(&'a self, other: &str) -> &'a str { if other.len() > self.data.len() { &self.data // Return with lifetime 'a } else { &self.data } } }

7. Advanced Borrowing Patterns

Borrowing in Structs

// Struct containing references struct RefHolder<'a> { reference: &'a i32, } // Struct with multiple references struct Pair<'a, 'b> { first: &'a str, second: &'b str, } impl<'a, 'b> Pair<'a, 'b> { fn new(first: &'a str, second: &'b str) -> Self { Pair { first, second } } fn longest(&self) -> &str where 'a: 'b, // 'a outlives 'b { if self.first.len() > self.second.len() { self.first } else { self.second } } } // Struct with mutable reference struct MutHolder<'a> { value: &'a mut i32, } impl<'a> MutHolder<'a> { fn increment(&mut self) { *self.value += 1; } } fn main() { let x = 42; let holder = RefHolder { reference: &x }; println!("Value: {}", holder.reference); let s1 = String::from("hello"); let s2 = String::from("world"); let pair = Pair::new(&s1, &s2); println!("Longest: {}", pair.longest()); let mut num = 10; let mut holder = MutHolder { value: &mut num }; holder.increment(); holder.increment(); println!("num after: {}", num); }

Borrowing in Enums

// Enum with references enum JsonValue<'a> { Null, Boolean(bool), Number(f64), String(&'a str), Array(Vec<JsonValue<'a>>), Object(Vec<(&'a str, JsonValue<'a>)>), } // Enum with different reference types enum Either<'a, 'b> { Left(&'a str), Right(&'b str), } impl<'a, 'b> Either<'a, 'b> { fn as_str(&self) -> &str { match self { Either::Left(s) => s, Either::Right(s) => s, } } } fn main() { let s = "hello"; let json = JsonValue::String(s); match json { JsonValue::String(s) => println!("String: {}", s), _ => println!("Not a string"), } let left = Either::Left("left"); let right = Either::Right("right"); println!("Left: {}", left.as_str()); println!("Right: {}", right.as_str()); }

8. Interior Mutability

RefCell for Interior Mutability

use std::cell::RefCell; struct Messenger { messages: RefCell<Vec<String>>, } impl Messenger { fn new() -> Self { Messenger { messages: RefCell::new(Vec::new()), } } fn send(&self, message: &str) { // Borrow mutably even though self is immutable self.messages.borrow_mut().push(message.to_string()); } fn get_messages(&self) -> Vec<String> { self.messages.borrow().clone() } fn count(&self) -> usize { self.messages.borrow().len() } } // Runtime borrow checking fn main() { let messenger = Messenger::new(); messenger.send("Hello"); messenger.send("World"); println!("Message count: {}", messenger.count()); // Multiple borrows { let msgs = messenger.messages.borrow(); println!("Messages: {:?}", *msgs); // This would panic at runtime // let mut msgs_mut = messenger.messages.borrow_mut(); // panic! } messenger.send("Another message"); // Iterate through messages for msg in messenger.get_messages() { println!("Message: {}", msg); } }

RefCell with Rc for Multiple Owners

use std::rc::Rc; use std::cell::RefCell; #[derive(Debug)] struct Node { value: i32, children: RefCell<Vec<Rc<Node>>>, } impl Node { fn new(value: i32) -> Rc<Self> { Rc::new(Node { value, children: RefCell::new(vec![]), }) } fn add_child(node: &Rc<Node>, child: Rc<Node>) { node.children.borrow_mut().push(child); } fn print_tree(node: &Rc<Node>, depth: usize) { println!("{}{}", " ".repeat(depth), node.value); for child in node.children.borrow().iter() { Node::print_tree(child, depth + 1); } } } fn main() { let root = Node::new(1); let child1 = Node::new(2); let child2 = Node::new(3); let grandchild = Node::new(4); Node::add_child(&root, Rc::clone(&child1)); Node::add_child(&root, Rc::clone(&child2)); Node::add_child(&child1, grandchild); Node::print_tree(&root, 0); // Multiple owners possible with Rc let shared = Node::new(42); let owner1 = Rc::clone(&shared); let owner2 = Rc::clone(&shared); Node::add_child(&owner1, Node::new(100)); println!("Owner1 count: {}", owner1.children.borrow().len()); println!("Owner2 count: {}", owner2.children.borrow().len()); }

9. Borrowing and Iterators

Iterator References

fn main() { let v = vec![1, 2, 3, 4, 5]; // Iterate over references for item in &v { println!("Item: {}", item); // item is &i32 } // Iterate over mutable references let mut v2 = vec![1, 2, 3, 4, 5]; for item in &mut v2 { *item *= 2; } println!("Doubled: {:?}", v2); // Iterator adapters with references let v3 = vec![1, 2, 3, 4, 5]; let sum: i32 = v3.iter().sum(); // iter() gives references println!("Sum: {}", sum); let doubled: Vec<i32> = v3.iter().map(|&x| x * 2).collect(); println!("Doubled: {:?}", doubled); // Filter with references let evens: Vec<&i32> = v3.iter().filter(|&&x| x % 2 == 0).collect(); println!("Evens: {:?}", evens); // Chaining operations let result: Vec<i32> = v3 .iter() .filter(|&&x| x > 2) .map(|&x| x * x) .collect(); println!("Squares of numbers > 2: {:?}", result); }

Custom Iterator with References

struct Window<'a, T> { slice: &'a [T], size: usize, pos: usize, } impl<'a, T> Window<'a, T> { fn new(slice: &'a [T], size: usize) -> Self { Window { slice, size, pos: 0, } } } impl<'a, T> Iterator for Window<'a, T> { type Item = &'a [T]; fn next(&mut self) -> Option<Self::Item> { if self.pos + self.size <= self.slice.len() { let window = &self.slice[self.pos..self.pos + self.size]; self.pos += 1; Some(window) } else { None } } } fn main() { let data = vec![1, 2, 3, 4, 5, 6]; let windows = Window::new(&data, 3); for window in windows { println!("Window: {:?}", window); } // Using with other iterator methods let sums: Vec<i32> = Window::new(&data, 2) .map(|w| w.iter().sum()) .collect(); println!("Sums of pairs: {:?}", sums); }

10. Borrowing and Closures

Closure Capture Modes

fn main() { let s = String::from("hello"); // Closure captures by reference (Fn) let print = || println!("s: {}", s); print(); println!("Still have s: {}", s); // s still accessible let mut counter = 0; // Closure captures by mutable reference (FnMut) let mut increment = || { counter += 1; println!("counter: {}", counter); }; increment(); increment(); // println!("counter: {}", counter); // Can't borrow here // Closure captures by value (FnOnce) let consume = || { let s = s; // s moved here println!("Consumed: {}", s); }; consume(); // consume(); // Can't call twice // println!("s: {}", s); // s moved // Mixing capture modes let a = String::from("a"); let mut b = String::from("b"); let c = String::from("c"); let mixed = move || { println!("a: {}", a); // by value (due to move) b.push_str(" modified"); // by mutable reference println!("b: {}", b); drop(c); // by value }; // a, b, c moved into closure mixed(); // mixed(); // Can't call twice (FnOnce) }

Borrowing in Returned Closures

// Returning closure that borrows fn make_adder(x: i32) -> impl Fn(i32) -> i32 { // x is copied/moved into closure move |y| x + y } // Returning closure that borrows from environment (doesn't work) // fn make_printer(s: &str) -> impl Fn() + '_ { // || println!("{}", s) // Need to specify lifetime // } // Correct version with lifetime fn make_printer<'a>(s: &'a str) -> impl Fn() + 'a { move || println!("{}", s) } // Closure that borrows mutably fn make_counter() -> impl FnMut() -> i32 { let mut count = 0; move || { count += 1; count } } fn main() { let add_five = make_adder(5); println!("5 + 3 = {}", add_five(3)); let s = String::from("hello"); let printer = make_printer(&s); printer(); let mut counter = make_counter(); println!("Count: {}", counter()); println!("Count: {}", counter()); println!("Count: {}", counter()); }

11. Borrowing and Error Handling

References in Results

#[derive(Debug)] struct Data { value: i32, } impl Data { fn new(value: i32) -> Self { Data { value } } fn get_value(&self) -> i32 { self.value } } fn find_data(data: &[Data], target: i32) -> Option<&Data> { data.iter().find(|&item| item.value == target) } fn modify_data(data: &mut [Data], target: i32) -> Result<&mut Data, String> { if let Some(item) = data.iter_mut().find(|item| item.value == target) { Ok(item) } else { Err(format!("Data with value {} not found", target)) } } fn process_data(data: &[Data]) -> Result<Vec<i32>, Box<dyn std::error::Error>> { let mut results = Vec::new(); for item in data { if item.value < 0 { return Err(format!("Negative value: {}", item.value).into()); } results.push(item.value * 2); } Ok(results) } fn main() -> Result<(), Box<dyn std::error::Error>> { let data = vec![ Data::new(1), Data::new(2), Data::new(3), Data::new(4), ]; if let Some(item) = find_data(&data, 3) { println!("Found: {}", item.value); } let mut mutable_data = vec![ Data::new(10), Data::new(20), Data::new(30), ]; match modify_data(&mut mutable_data, 20) { Ok(item) => { item.value += 5; println!("Modified: {}", item.value); } Err(e) => println!("Error: {}", e), } let processed = process_data(&data)?; println!("Processed: {:?}", processed); Ok(()) }

12. Best Practices and Common Patterns

Borrowing Guidelines

// 1. Use references for read-only access fn read_only(data: &[i32]) -> i32 { data.iter().sum() } // 2. Use mutable references when you need to modify fn modify_in_place(data: &mut [i32]) { for item in data { *item *= 2; } } // 3. Return owned data when you need to give ownership fn create_data() -> Vec<i32> { vec![1, 2, 3, 4, 5] } // 4. Use slices for more flexible borrowing fn process_slice(data: &[i32]) -> i32 { data.iter().sum() } // 5. Avoid long-lived borrows fn process_with_temp() -> i32 { let data = vec![1, 2, 3, 4, 5]; // Borrow only as long as needed let sum = { let slice = &data[..]; slice.iter().sum() }; // Borrow ends here // Can modify data here sum } // 6. Use interior mutability sparingly use std::cell::RefCell; struct Cache { data: RefCell<Vec<i32>>, } impl Cache { fn new() -> Self { Cache { data: RefCell::new(Vec::new()), } } fn get(&self, index: usize) -> Option<i32> { self.data.borrow().get(index).copied() } fn set(&self, value: i32) { self.data.borrow_mut().push(value); } } fn main() { // 1. Read-only let data = vec![1, 2, 3]; let sum = read_only(&data); println!("Sum: {}", sum); // 2. Modify in place let mut data = vec![1, 2, 3]; modify_in_place(&mut data); println!("Modified: {:?}", data); // 3. Create owned data let new_data = create_data(); println!("New data: {:?}", new_data); // 4. Work with slices let slice = &data[1..3]; println!("Slice sum: {}", process_slice(slice)); // 5. Temporary borrow let result = process_with_temp(); println!("Result: {}", result); // 6. Interior mutability let cache = Cache::new(); cache.set(42); cache.set(100); println!("Cache[0]: {:?}", cache.get(0)); println!("Cache[1]: {:?}", cache.get(1)); }

Common Patterns

// Builder pattern with references struct QueryBuilder<'a> { table: &'a str, condition: Option<&'a str>, limit: Option<usize>, } impl<'a> QueryBuilder<'a> { fn new(table: &'a str) -> Self { QueryBuilder { table, condition: None, limit: None, } } fn condition(mut self, condition: &'a str) -> Self { self.condition = Some(condition); self } fn limit(mut self, limit: usize) -> Self { self.limit = Some(limit); self } fn build(&self) -> String { let mut query = format!("SELECT * FROM {}", self.table); if let Some(cond) = self.condition { query.push_str(&format!(" WHERE {}", cond)); } if let Some(limit) = self.limit { query.push_str(&format!(" LIMIT {}", limit)); } query } } // Visitor pattern with references trait Visitor<'a> { fn visit_str(&mut self, s: &'a str); fn visit_int(&mut self, i: i32); } struct Printer { output: String, } impl<'a> Visitor<'a> for Printer { fn visit_str(&mut self, s: &'a str) { self.output.push_str(&format!("String: {}\n", s)); } fn visit_int(&mut self, i: i32) { self.output.push_str(&format!("Int: {}\n", i)); } } fn visit_all<'a, V: Visitor<'a>>(visitor: &mut V, data: &[&'a str]) { for item in data { if let Ok(num) = item.parse::<i32>() { visitor.visit_int(num); } else { visitor.visit_str(item); } } } fn main() { // Builder pattern let query = QueryBuilder::new("users") .condition("age > 18") .limit(10) .build(); println!("Query: {}", query); // Visitor pattern let data = vec!["hello", "42", "world", "123"]; let mut printer = Printer { output: String::new(), }; visit_all(&mut printer, &data); println!("Visitor output:\n{}", printer.output); }

Conclusion

Rust's borrowing and reference system is a cornerstone of its memory safety guarantees:

Key Takeaways

1. Borrowing Rules: At any time, you can have either:

• One mutable reference
• Any number of immutable references

1. References:

• &T: Immutable reference (shared borrow)
• &mut T: Mutable reference (exclusive borrow)

1. Lifetimes: Ensure references never outlive the data they point to
2. Dereferencing: Automatic and explicit dereferencing with *
3. Interior Mutability: RefCell<T> for runtime borrow checking

Best Practices

• Prefer immutable references by default
• Use mutable references only when mutation is needed
• Keep borrow scopes small to minimize conflicts
• Use slices (&[T]) for flexible borrowing
• Consider interior mutability only when necessary
• Understand lifetimes for complex reference relationships

Common Patterns

Pattern	Use Case
&self	Read-only methods
&mut self	Modifying methods
&[T]	Function parameters for sequences
&str	String parameters
RefCell<T>	Interior mutability
Rc<RefCell<T>>	Shared mutable data

Rust's borrowing system provides compile-time guarantees that prevent entire classes of bugs, making it one of the language's most powerful features while requiring some adjustment for developers coming from other languages.