🎬 Rust Ownership in 30 seconds Visual walkthrough of ownership, moves, and automatic memory management.

📝 Text version (for readers / accessibility)

• Each value in Rust has exactly one owner — when the owner goes out of scope, the value is dropped

• Assignment moves ownership by default; the original binding becomes invalid

• Borrowing (&T / &mut T) lets you reference data without taking ownership

• The compiler enforces: many shared references OR one mutable reference, never both

• No garbage collector needed — memory is freed deterministically at scope exit

103: Borrowing Shared

Difficulty: Intermediate Category: Ownership Concept: `&T`: shared references (multiple readers) Key Insight: Shared borrows allow multiple simultaneous readers — the compiler guarantees no one writes during shared access

// 103: Shared Borrowing — &T
// Multiple readers, no writers

fn sum(data: &[i32]) -> i32 {
    data.iter().sum()
}

fn count(data: &[i32]) -> usize {
    data.len()
}

fn average(data: &[i32]) -> f64 {
    // Multiple shared borrows simultaneously — perfectly safe
    let s = sum(data);   // &data borrow 1
    let c = count(data); // &data borrow 2 — fine!
    s as f64 / c as f64
}

fn first_and_last(data: &[i32]) -> Option<(i32, i32)> {
    if data.is_empty() { None }
    else { Some((data[0], data[data.len() - 1])) }
}

// Multiple shared references can coexist
fn demonstrate_multiple_borrows() {
    let data = vec![1, 2, 3, 4, 5];
    let r1 = &data;
    let r2 = &data;
    let r3 = &data;
    // All three references valid simultaneously
    println!("r1={:?}, r2={:?}, r3={:?}", r1[0], r2[1], r3[2]);
}

fn main() {
    let data = vec![1, 2, 3, 4, 5];
    println!("average: {}", average(&data));
    println!("first_last: {:?}", first_and_last(&data));
    demonstrate_multiple_borrows();
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_average() {
        assert!((average(&[1, 2, 3, 4, 5]) - 3.0).abs() < 0.001);
    }

    #[test]
    fn test_first_and_last() {
        assert_eq!(first_and_last(&[10, 20, 30]), Some((10, 30)));
        assert_eq!(first_and_last(&[]), None);
    }

    #[test]
    fn test_multiple_borrows() {
        let v = vec![1, 2, 3];
        let r1 = &v;
        let r2 = &v;
        assert_eq!(r1.len(), r2.len());
    }
}

(* 103: Shared Borrowing *)
(* OCaml: immutable by default, no borrow checker needed *)

(* Approach 1: Multiple "readers" — always safe in OCaml *)
let sum_list lst = List.fold_left ( + ) 0 lst
let count_list lst = List.length lst

let multiple_readers () =
  let data = [1; 2; 3; 4; 5] in
  let s = sum_list data in      (* "borrow" 1 *)
  let c = count_list data in    (* "borrow" 2 — no problem *)
  let avg = float_of_int s /. float_of_int c in
  avg

(* Approach 2: Passing by reference (mutable structures) *)
let read_array_twice arr =
  let first = arr.(0) in
  let last = arr.(Array.length arr - 1) in
  (first, last)

(* Tests *)
let () =
  assert (abs_float (multiple_readers () -. 3.0) < 0.001);
  assert (read_array_twice [|10; 20; 30|] = (10, 30));
  Printf.printf "✓ All tests passed\n"

📊 Detailed Comparison

Core Insight

Shared borrows allow multiple simultaneous readers — the compiler guarantees no one writes during shared access

OCaml Approach

See example.ml for implementation

Rust Approach

See example.rs for implementation

Comparison Table

Feature	OCaml	Rust
See	example.ml	example.rs