898-borrowing-mutable — Mutable Borrowing (&mut T)

pub fn increment(c: &mut Counter) {
    c.count += 1;
}

pub fn sum_into(data: &[i32], total: &mut i32) {
    for &x in data {
        *total += x;
    }
}

pub fn reverse_in_place(arr: &mut [i32]) {
    let n = arr.len();
    for i in 0..n / 2 {
        arr.swap(i, n - 1 - i);
    }
}

(* Mutable record fields — mutation is opt-in per field *)
type counter = { mutable count : int }

let increment c = c.count <- c.count + 1

(* Ref cells — first-class mutable references *)
let sum_into total lst =
  List.iter (fun x -> total := !total + x) lst

(* Mutable arrays — in-place mutation *)
let reverse_in_place arr =
  let n = Array.length arr in
  for i = 0 to n / 2 - 1 do
    let tmp = arr.(i) in
    arr.(i) <- arr.(n - 1 - i);
    arr.(n - 1 - i) <- tmp
  done

#![allow(clippy::all)]
// Example 104: Mutable References (&mut T)
//
// Only ONE &mut T at a time. No &T while &mut T exists.
// This prevents data races at compile time.

// Approach 1: Mutable reference to a struct
pub struct Counter {
    pub count: i32,
}

pub fn increment(c: &mut Counter) {
    c.count += 1;
}

pub fn get_count(c: &Counter) -> i32 {
    c.count
}

// Approach 2: Mutable reference for accumulation
// Takes a mutable reference to the total — the caller owns the value,
// and we write into it without taking ownership.
pub fn sum_into(data: &[i32], total: &mut i32) {
    for &x in data {
        *total += x;
    }
}

// Approach 3: In-place mutation via &mut [T]
// Reverses a slice in place — no allocation, mutates through the reference.
pub fn reverse_in_place(arr: &mut [i32]) {
    let n = arr.len();
    for i in 0..n / 2 {
        arr.swap(i, n - 1 - i);
    }
}

// Approach 4: Exclusive access — demonstrates borrow checker rules.
// We can pass &mut to a helper and regain access after it returns.
pub fn double_all(values: &mut [i32]) {
    for v in values.iter_mut() {
        *v *= 2;
    }
}

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

    #[test]
    fn test_counter_increment() {
        let mut c = Counter { count: 0 };
        increment(&mut c);
        increment(&mut c);
        increment(&mut c);
        assert_eq!(get_count(&c), 3);
    }

    #[test]
    fn test_counter_starts_at_zero() {
        let c = Counter { count: 0 };
        assert_eq!(get_count(&c), 0);
    }

    #[test]
    fn test_sum_into_accumulates() {
        let mut total = 0;
        sum_into(&[1, 2, 3, 4, 5], &mut total);
        assert_eq!(total, 15);
    }

    #[test]
    fn test_sum_into_empty_slice() {
        let mut total = 42;
        sum_into(&[], &mut total);
        assert_eq!(total, 42);
    }

    #[test]
    fn test_sum_into_accumulates_across_calls() {
        let mut total = 0;
        sum_into(&[1, 2, 3], &mut total);
        sum_into(&[4, 5], &mut total);
        assert_eq!(total, 15);
    }

    #[test]
    fn test_reverse_in_place_even() {
        let mut arr = [1, 2, 3, 4];
        reverse_in_place(&mut arr);
        assert_eq!(arr, [4, 3, 2, 1]);
    }

    #[test]
    fn test_reverse_in_place_odd() {
        let mut arr = [1, 2, 3];
        reverse_in_place(&mut arr);
        assert_eq!(arr, [3, 2, 1]);
    }

    #[test]
    fn test_reverse_in_place_single() {
        let mut arr = [42];
        reverse_in_place(&mut arr);
        assert_eq!(arr, [42]);
    }

    #[test]
    fn test_reverse_in_place_empty() {
        let mut arr: [i32; 0] = [];
        reverse_in_place(&mut arr);
        assert_eq!(arr, []);
    }

    #[test]
    fn test_double_all() {
        let mut values = vec![1, 2, 3, 4];
        double_all(&mut values);
        assert_eq!(values, vec![2, 4, 6, 8]);
    }

    #[test]
    fn test_double_all_empty() {
        let mut values: Vec<i32> = vec![];
        double_all(&mut values);
        assert_eq!(values, vec![]);
    }
}

(* Example 104: Mutable References — OCaml Mutable Fields → Rust &mut *)

(* Approach 1: Mutable record fields *)
type counter = { mutable count : int }

let increment c = c.count <- c.count + 1
let get_count c = c.count

let approach1 () =
  let c = { count = 0 } in
  increment c;
  increment c;
  increment c;
  assert (get_count c = 3);
  Printf.printf "Counter: %d\n" (get_count c)

(* Approach 2: Ref cells — mutable references *)
let approach2 () =
  let total = ref 0 in
  List.iter (fun x -> total := !total + x) [1; 2; 3; 4; 5];
  assert (!total = 15);
  Printf.printf "Total: %d\n" !total

(* Approach 3: Mutable arrays *)
let reverse_in_place arr =
  let n = Array.length arr in
  for i = 0 to n / 2 - 1 do
    let tmp = arr.(i) in
    arr.(i) <- arr.(n - 1 - i);
    arr.(n - 1 - i) <- tmp
  done

let approach3 () =
  let arr = [| 1; 2; 3; 4; 5 |] in
  reverse_in_place arr;
  assert (arr = [| 5; 4; 3; 2; 1 |]);
  Printf.printf "Reversed: %s\n"
    (String.concat ", " (Array.to_list (Array.map string_of_int arr)))

let () =
  approach1 ();
  approach2 ();
  approach3 ();
  Printf.printf "✓ All tests passed\n"