Rust Vec

// 1. Empty vector. Does not allocate heap memory until the first element is pushed.
let mut v1: Vec<i32> = Vec::new();

// 2. Pre-allocated vector. Allocates heap space for at least 10 elements.
// The underlying allocator may round up the allocation size, so capacity can be >= 10.
// Prevents reallocation overhead if the maximum size is known upfront.
let mut v2: Vec<i32> = Vec::with_capacity(10);

// 3. Macro initialization with a list of elements.
let v3 = vec![1, 2, 3];

// 4. Macro initialization with a repeated value (requires T to implement Clone).
let v4 = vec![0; 5]; // Equivalent to [0, 0, 0, 0, 0]

{
    let v = vec![String::from("A"), String::from("B")];
    // v owns the heap-allocated Strings.
} // v is dropped. The Strings are dropped, then the Vec's buffer is deallocated.

let mut v = vec![10, 20, 30, 40, 50];

// Deref coercion allows calling slice methods directly on the Vec
let contains_thirty = v.contains(&30);

// Borrowing a specific range as an immutable slice (&[i32]) via Index
let slice: &[i32] = &v[1..4]; // [20, 30, 40]

// Borrowing as a mutable slice (&mut [i32]) via DerefMut coercion
let mut_slice: &mut [i32] = &mut v;
mut_slice[0] = 99;

let v = vec![10, 20, 30];

// 1. Direct indexing: v[1] is a place expression evaluating to the element (type T).
// Taking a reference (&v[1]) yields &T. Panics if index >= len.
let val_ref: &i32 = &v[1]; 

// 2. Safe access: Returns Option<&T>. Returns None if index >= len.
let safe_val: Option<&i32> = v.get(5);

// 3. Mutable access: Returns Option<&mut T>.
let mut v_mut = vec![10, 20, 30];
if let Some(val) = v_mut.get_mut(0) {
    *val += 1; // v_mut is now [11, 20, 30]
}

let mut v = vec![1, 2, 3];

// 1. Immutable Borrow: Yields &T. Vector remains accessible.
for val in &v { /* ... */ }

// 2. Mutable Borrow: Yields &mut T. Vector remains accessible.
for val in &mut v { /* ... */ }

// 3. Consuming (IntoIter): Yields T. Vector is moved and destroyed.
for val in v { /* ... */ } 
// v is no longer accessible here.