Mastering Ownership, Moves, Borrowing, and Lifetimes in Rust

struct FileGuard {
    path: String,
    handle: File,
}

impl Drop for FileGuard {
    fn drop(&mut self) {
        println!("Closing file: {}", self.path);
        // File::drop() called automatically after this
    }
}

fn main() {
    let _guard = FileGuard {
        path: "data.txt".into(),
        handle: File::create("data.txt").unwrap(),
    };
    // Prints "Closing file: data.txt" when _guard goes out of scope
}

struct Outer {
    first: Inner,
    second: Inner,
}

struct Inner(&'static str);

impl Drop for Inner {
    fn drop(&mut self) {
        println!("Dropping {}", self.0);
    }
}

fn main() {
    let _container = Outer {
        first: Inner("first"),
        second: Inner("second"),
    };

    // Output:
    // Dropping first
    // Dropping second
}

struct PanicDrop;

impl Drop for PanicDrop {
    fn drop(&mut self) {
        panic!("Drop panic!"); // ABORT if already unwinding
    }
}

fn main() {
    let _guard = PanicDrop;
    panic!("First panic"); // Second panic in drop causes abort
}

struct Transaction {
    committed: bool,
}

impl Transaction {
    fn new() -> Self {
        Self { committed: false }
    }

    fn commit(mut self) {
        self.committed = true;
        println!("Transaction committed");
    }
}

impl Drop for Transaction {
    fn drop(&mut self) {
        if !self.committed {
            panic!("Transaction dropped without commit!");
        }
    }
}

fn main() {
    let tx = Transaction::new();
    tx.commit(); // Must explicitly commit
}

// This doesn't compile:
#[derive(Copy, Clone)]
struct Invalid;

impl Drop for Invalid {
    fn drop(&mut self) {
        // ERROR: Copy types cannot implement Drop
    }
}

use std::mem::{size_of, align_of};

#[derive(Debug)]
struct Unoptimized {
    a: u8,      // 1 byte + 7 padding
    b: u64,     // 8 bytes (requires 8-byte alignment)
    c: u16,     // 2 bytes + 6 padding
}

#[derive(Debug)]
struct Optimized {
    b: u64,     // 8 bytes
    c: u16,     // 2 bytes
    a: u8,      // 1 byte + 5 padding
}

fn main() {
    println!("Unoptimized: {} bytes", size_of::<Unoptimized>()); // 24 bytes
    println!("Optimized: {} bytes", size_of::<Optimized>());     // 16 bytes

    // Reorder fields from largest to smallest for optimal packing
}

use std::mem::size_of;

fn main() {
    // Regular pointer: 8 bytes (on 64-bit)
    let ptr: *const i32 = &42;
    println!("Regular pointer: {} bytes", size_of::<*const i32>()); // 8

    // Slice: pointer + length = 16 bytes
    let slice: &[i32] = &[1, 2, 3];
    println!("Slice ref: {} bytes", size_of::<&[i32]>()); // 16

    // Trait object: pointer + vtable = 16 bytes
    let trait_obj: &dyn std::fmt::Debug = &42;
    println!("Trait object: {} bytes", size_of::<&dyn std::fmt::Debug>()); // 16

    // String: pointer + length + capacity = 24 bytes
    println!("String: {} bytes", size_of::<String>()); // 24
}

// Default Rust layout (optimized, unspecified order)
#[repr(Rust)]
struct Default {
    a: u8,
    b: u32,
}

// C-compatible layout (stable ordering)
#[repr(C)]
struct CCompat {
    a: u8,
    // 3 bytes padding
    b: u32,
}

// Packed layout (no padding, slower access)
#[repr(packed)]
struct Packed {
    a: u8,
    b: u32, // Only 1 byte after a, misaligned!
}

// Transparent (single-field wrapper, same layout as inner type)
#[repr(transparent)]
struct NewType(u32);

fn main() {
    use std::mem::size_of;

    println!("Default: {} bytes", size_of::<Default>());   // 8 (optimized)
    println!("C: {} bytes", size_of::<CCompat>());         // 8 (explicit padding)
    println!("Packed: {} bytes", size_of::<Packed>());     // 5 (no padding)
    println!("NewType: {} bytes", size_of::<NewType>());   // 4 (same as u32)
}

fn main() {
    let data = vec![1, 2, 3];

    // FnOnce: Takes ownership, can only be called once
    let consume = || {
        drop(data); // Consumes data
    };
    consume();
    // consume(); // ERROR: cannot call twice

    // Fn: Borrows immutably, can be called multiple times
    let data2 = vec![4, 5, 6];
    let borrow = || {
        println!("{:?}", data2); // Immutable borrow
    };
    borrow();
    borrow(); // OK: can call multiple times

    // FnMut: Borrows mutably, can be called multiple times
    let mut data3 = vec![7, 8, 9];
    let mut mutate = || {
        data3.push(10); // Mutable borrow
    };
    mutate();
    mutate(); // OK: can call multiple times
    println!("{:?}", data3); // [7, 8, 9, 10, 10]
}

fn main() {
    let data = vec![1, 2, 3];

    // Force move even if only immutable access needed
    let closure = move || {
        println!("{:?}", data); // data moved into closure
    };

    // println!("{:?}", data); // ERROR: data was moved
    closure();
}

use tokio;

async fn process_data(data: Vec<i32>) -> i32 {
    // Ownership transferred into async block
    data.iter().sum()
}

#[tokio::main]
async fn main() {
    let numbers = vec![1, 2, 3, 4, 5];

    let result = process_data(numbers).await;
    // numbers moved, cannot use here

    println!("Sum: {}", result);
}

use std::mem::size_of;

struct ZeroSized;

struct Unit;

enum Never {}

fn main() {
    println!("ZeroSized: {} bytes", size_of::<ZeroSized>()); // 0
    println!("Unit: {} bytes", size_of::<Unit>());           // 0
    println!("(): {} bytes", size_of::<()>());               // 0
    println!("Never: {} bytes", size_of::<Never>());         // 0

    // Moves of ZSTs compile to nothing
    let zst1 = ZeroSized;
    let zst2 = zst1; // No actual copy or move in assembly
}

use std::marker::PhantomData;

struct OwnedData<T> {
    _marker: PhantomData<T>,
    // Pretends to own T for drop checker
}

impl<T> OwnedData<T> {
    fn new() -> Self {
        Self {
            _marker: PhantomData,
        }
    }
}

// Drop checker knows this type "owns" T
unsafe impl<T: Send> Send for OwnedData<T> {}
unsafe impl<T: Sync> Sync for OwnedData<T> {}

fn main() {
    let _owned: OwnedData<String> = OwnedData::new();
    // Behaves as if it owns String for trait bounds
}

use std::marker::PhantomData;

struct Invariant<'a, T> {
    _marker: PhantomData<&'a mut T>,
    // Invariant in both 'a and T
}

struct Covariant<'a, T> {
    _marker: PhantomData<&'a T>,
    // Covariant in both 'a and T
}

struct Contravariant<T> {
    _marker: PhantomData<fn(T)>,
    // Contravariant in T
}

#[derive(Debug)]
struct Config {
    version: u32,        // Copy
    database_url: String, // Move
    api_key: String,      // Move
}

fn main() {
    let config = Config {
        version: 1,
        database_url: String::from("postgres://localhost"),
        api_key: String::from("secret_key"),
    };

    // Pattern matching with partial move
    match config {
        Config { version, ref database_url, .. } => {
            println!("Version: {}", version);        // version copied
            println!("DB: {}", database_url);        // database_url borrowed
        }
    }

    // config.version still accessible (Copy)
    println!("Version: {}", config.version);

    // config.database_url still accessible (was borrowed, not moved)
    println!("DB: {}", config.database_url);

    // Can move api_key now
    let key = config.api_key;

    // println!("{:?}", config); // ERROR: config partially moved
}

fn main() {
    let array = [
        String::from("a"),
        String::from("b"),
        String::from("c"),
    ];

    // Cannot move out of array by indexing
    // let first = array; // ERROR

    // Use pattern matching or into_iter
    let [first, second, third] = array;
    println!("{} {} {}", first, second, third);

    // Alternative: into_iter
    let array2 = [String::from("x"), String::from("y")];
    for item in array2 {
        println!("{}", item); // Moves each item
    }
}

fn main() {
    let mut data = Some(String::from("hello"));

    // Option::take moves out while leaving None
    let value = data.take();
    println!("{:?}", value);  // Some("hello")
    println!("{:?}", data);   // None

    // mem::replace swaps with a new value
    use std::mem;

    let mut data2 = String::from("world");
    let old_value = mem::replace(&mut data2, String::from("new"));
    println!("Old: {}, New: {}", old_value, data2);

    // mem::take uses Default
    let mut data3 = vec![1, 2, 3];
    let taken = mem::take(&mut data3);
    println!("Taken: {:?}, Remaining: {:?}", taken, data3); "Taken: [1, 2, 3], Remaining: []"
}

struct Resource(&'static str);

impl Drop for Resource {
    fn drop(&mut self) {
        println!("Dropping {}", self.0);
    }
}

fn main() {
    let data = (Resource("first"), Resource("second"));

    let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
        let first = data.0; // Partial move
        panic!("Oops!");
        drop(first); // Never reached
    }));

    // Output during unwinding:
    // "Dropping first"  - first was moved to local, dropped during unwind
    //  Caught panic
    // "Dropping second" - second remains in partially-moved data, dropped during unwind

    match result {
        Ok(_) => println!("No panic"),
        Err(_) => println!("Caught panic"),
    }
}

fn risky_operation(mut vec: Vec<String>) -> Vec<String>{
    // Take ownership
    let item = vec.pop().unwrap();

    // If this panics, vec is moved but item is dropped
    process_item(item);

    // vec ownership transferred back through return
    vec
}

fn process_item(s: String) {
    // Might panic
    println!("{}", s);
}

fn demonstrate_closure_traits() {
    let data = vec![1, 2, 3];

    // Closure that only borrows
    let print = || println!("{:?}", data);
    call_fn(print); // Implements Fn
    call_fn(print); // Can call multiple times

    // Closure that mutates
    let mut counter = 0;
    let mut increment = || {
        counter += 1;
        println!("Count: {}", counter);
    };
    call_fn_mut(&mut increment); // Implements FnMut
    call_fn_mut(&mut increment); // Can call multiple times

    // Closure that consumes
    let consume = || drop(data);
    call_fn_once(consume); // Implements FnOnce
    // call_fn_once(consume); // ERROR: can only call once
}

fn call_fn<F: Fn()>(f: F) {
    f();
}

fn call_fn_mut<F: FnMut()>(f: &mut F) {
    f();
}

fn call_fn_once<F: FnOnce()>(f: F) {
    f();
}

fn main() {
    demonstrate_closure_traits();
}

FnOnce (base trait)
  ↑
FnMut (can be called multiple times with mutable access)
  ↑
Fn (can be called multiple times with shared access)

fn main() {
    let data = vec![String::from("a"), String::from("b")];

    // iter(): borrows elements (&T)
    for item in data.iter() {
        println!("{}", item); // item: &String
    }
    println!("data still valid: {:?}", data);

    // iter_mut(): mutably borrows elements (&mut T)
    let mut data_mut = vec![String::from("x"), String::from("y")];
    for item in data_mut.iter_mut() {
        item.push_str("!"); // item: &mut String
    }
    println!("modified: {:?}", data_mut);

    // into_iter(): takes ownership (T)
    for item in data {
        println!("{}", item); // item: String
    } // data moved, no longer valid
    // println!("{:?}", data); // ERROR
}

struct DataIterator {
    data: Vec<String>,
    index: usize,
}

impl Iterator for DataIterator {
    type Item = String; // Owns items

    fn next(&mut self) -> Option<Self::Item> {
        if self.index < self.data.len() {
            let item = self.data.swap_remove(self.index);
            Some(item)
        } else {
            None
        }
    }
}

fn main() {
    let iter = DataIterator {
        data: vec![String::from("a"), String::from("b")],
        index: 0,
    };

    for item in iter {
        println!("{}", item); // Owns each item
    }
}

fn main() {
    let mut data = vec![1, 2, 3, 4, 5, 6];

    // split_at_mut creates two non-overlapping mutable slices
    let (left, right) = data.split_at_mut(3);

    left[0] = 10;
    right[0] = 40;

    println!("{:?}", data); // [10, 2, 3, 40, 5, 6]
}

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

fn main() {
    let mut p = Point { x: 0, y: 0 };

    // Can borrow different fields mutably
    let x = &mut p.x;
    let y = &mut p.y;

    *x = 10;
    *y = 20;

    println!("Point: ({}, {})", p.x, p.y);
}

fn main() {
    let mut data = (String::from("a"), String::from("b"));

    // Conservative: compiler can't prove disjoint access
    let first = &mut data.0;
    // let second = &mut data.1; // ERROR in some contexts

    // Workaround: destructure
    let (ref mut first, ref mut second) = data;
    first.push_str("pple");
    second.push_str("anana");

    println!("{}, {}", first, second);
}

use std::cell::{Cell, RefCell};

fn main() {
    // Cell: Copy types only, no runtime checking
    let counter = Cell::new(0);
    let ref1 = &counter;
    let ref2 = &counter;

    ref1.set(ref1.get() + 1);
    ref2.set(ref2.get() + 1);

    println!("Counter: {}", counter.get()); // 2

    // RefCell: Any type, runtime borrow checking
    let data = RefCell::new(vec![1, 2, 3]);

    {
        let mut borrowed = data.borrow_mut();
        borrowed.push(4);
    } // Mutable borrow ends

    let borrowed = data.borrow();
    println!("{:?}", *borrowed); // [1, 2, 3, 4]
}

use std::sync::{Arc, Mutex, RwLock};

fn main() {
    // Mutex: Exclusive access, blocks threads
    let counter = Arc::new(Mutex::new(0));

    let handles: Vec<_> = (0..10).map(|_| {
        let counter = Arc::clone(&counter);
        std::thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        })
    }).collect();

    for handle in handles {
        handle.join().unwrap();
    }

    println!("Counter: {}", *counter.lock().unwrap()); // 10

    // RwLock: Multiple readers or one writer
    let data = Arc::new(RwLock::new(vec![1, 2, 3]));

    // Multiple readers
    let data1 = Arc::clone(&data);
    let data2 = Arc::clone(&data);

    std::thread::scope(|s| {
        s.spawn(|| {
            let read = data1.read().unwrap();
            println!("Read 1: {:?}", *read);
        });

        s.spawn(|| {
            let read = data2.read().unwrap();
            println!("Read 2: {:?}", *read);
        });
    });
}

use std::cell::UnsafeCell;

struct MyCell<T> {
    value: UnsafeCell<T>,
}

impl<T> MyCell<T> {
    fn new(value: T) -> Self {
        Self {
            value: UnsafeCell::new(value),
        }
    }

    fn get(&self) -> &T {
        unsafe { &*self.value.get() }
    }

    fn set(&self, value: T) {
        unsafe {
            *self.value.get() = value;
        }
    }
}

// SAFETY: This is a simplified example. Real implementation needs proper synchronization

use std::rc::Rc;

fn print_str(s: &str) {
    println!("{}", s);
}

fn main() {
    let owned = String::from("hello");
    print_str(&owned); // &String -> &str

    let boxed = Box::new(String::from("world"));
    print_str(&boxed); // &Box -> &String -> &str

    let rc = Rc::new(String::from("Rust"));
    print_str(&rc); // &Rc -> &String -> &str
}

use std::ops::Deref;

struct MyBox<T>(T);

impl<T> MyBox<T> {
    fn new(value: T) -> Self {
        MyBox(value)
    }
}

impl<T> Deref for MyBox<T> {
    type Target = T;

    fn deref(&self) -> &T {
        &self.0
    }
}

fn main() {
    let boxed = MyBox::new(String::from("Rust"));

    // Automatic deref coercion
    let len = boxed.len(); // MyBox -> String -> str
    println!("Length: {}", len);
}

fn assign<'a, 'b: 'a>(long: &'a str, short: &'b str) -> &'a str {
    // 'b: 'a means 'b outlives 'a
    // &'b str is a subtype of &'a str (covariant)
    short // OK: can return shorter lifetime as longer lifetime
}

fn main() {
    let long_lived = String::from("long");
    let result;

    {
        let short_lived = String::from("short");
        result = assign(&long_lived, &short_lived);
        // short_lived dropped here
    }

    // println!("{}", result); // ERROR: result references short_lived
}

fn attempt_shorten<'a, 'b>(long: &'a mut &'static str, short: &'b mut &'b str) {
    // This would be unsound if &mut was covariant:
    // *long = *short; // ERROR: Cannot assign &'b str to &'static str

    // Invariance prevents this unsound operation
}

fn main() {
    let mut static_ref: &'static str = "static";
    let local = String::from("local");
    let mut local_ref: &str = &local;

    // attempt_shorten(&mut static_ref, &mut local_ref);
    // If allowed, static_ref would point to dropped local!
}

fn example() {
    // Function that accepts &'static str
    let f: fn(&'static str) = |s| println!("{}", s);

    // Can use it where fn(&'a str) is expected (contravariant)
    // A function accepting longer lifetimes works for shorter ones
    call_with_local(f);
}

fn call_with_local<'a>(f: fn(&'a str)) {
    let local = String::from("local");
    f(&local);
}

fn main() {
    example();
}

use std::cell::Cell;

fn main() {
    // Covariant: Can substitute longer lifetime with shorter
    let _covariant: &'static str = "hello";
    let _shorter: &str = _covariant; // OK

    // Invariant: Cannot substitute lifetimes
    let cell: Cell<&'static str> = Cell::new("hello");
    // let cell2: Cell<&str> = cell; // ERROR: invariant

    // Why invariance matters:
    let mut data = Some(&0);
    {
        let local = 42;
        // If Cell<&'static str> was covariant:
        // cell.set(&local); // Would compile but be unsound!
    }
}

// Function that works for any lifetime 'a
fn call_with_ref<F>(f: F)
where
    F: for<'a> Fn(&'a str) -> &'a str, // HRTB
{
    let data = String::from("hello");
    let result = f(&data);
    println!("{}", result);
}

fn main() {
    call_with_ref(|s| s);
}

// Without HRTB (doesn't work):
trait Processor<'a> {
    fn process(&self, input: &'a str) -> &'a str;
}

// With HRTB (works):
trait ProcessorHRTB {
    fn process(&self, input: &str) -> &str; // Elided lifetime
}

fn use_processor<P>(processor: P)
where
    P: for<'a> Fn(&'a str) -> &'a str,
{
    let data1 = String::from("first");
    let result1 = processor(&data1);
    println!("{}", result1);

    let data2 = String::from("second");
    let result2 = processor(&data2);
    println!("{}", result2);
}

fn main() {
    use_processor(|s| s);
}

// Pattern 1: Closures that work with any lifetime
fn map_ref<F, T, U>(data: &[T], f: F) -> Vec<U>
where
    F: for<'a> Fn(&'a T) -> U,
{
    data.iter().map(|x| f(x)).collect()
}

// Pattern 2: Trait bounds with lifetime parameters
trait Apply {
    fn apply<F>(&self, f: F)
    where
        F: for<'a> Fn(&'a Self);
}

impl<T> Apply for T {
    fn apply<F>(&self, f: F)
    where
        F: for<'a> Fn(&'a Self),
    {
        f(self);
    }
}

fn main() {
    let numbers = vec![1, 2, 3];
    let strings = map_ref(&numbers, |n| n.to_string());
    println!("{:?}", strings);

    42.apply(|x| println!("Value: {}", x));
}

fn covariant_example() {
    let static_str: &'static str = "hello";

    // &'static str is a subtype of &'a str for any 'a
    fn takes_any<'a>(s: &'a str) {
        println!("{}", s);
    }

    takes_any(static_str); // OK: covariant
}

fn invariant_example() {
    use std::cell::Cell;

    let static_cell: Cell<&'static str> = Cell::new("hello");

    // Cannot treat Cell<&'static str> as Cell<&'a str>
    fn takes_cell<'a>(_cell: Cell<&'a str>) {}

    // takes_cell(static_cell); // ERROR: invariant
}

fn contravariant_example() {
    // fn(&'static str) is a subtype of fn(&'a str)
    let f: fn(&'static str) = |s| println!("{}", s);

    fn call_with_short<'a>(f: fn(&'a str)) {
        let local = String::from("local");
        f(&local);
    }

    call_with_short(f); // OK: contravariant in argument position
}

// This doesn't compile:
struct SelfReferential {
    data: String,
    pointer: *const String, // Points to data field
}

// Moving invalidates the pointer!

use std::pin::Pin;
use std::marker::PhantomPinned;

struct SelfReferential {
    data: String,
    pointer: Option<*const String>,
    _pin: PhantomPinned, // Makes this !Unpin
}

impl SelfReferential {
    fn new(data: String) -> Pin<Box<Self>> {
        let mut boxed = Box::pin(SelfReferential {
            data,
            pointer: None,
            _pin: PhantomPinned,
        });

        // SAFETY: We never move out of Pin>
        unsafe {
            let mut_ref = Pin::as_mut(&mut boxed);
            let ptr = &mut_ref.get_unchecked_mut().data as *const String;
            mut_ref.get_unchecked_mut().pointer = Some(ptr);
        }

        boxed
    }

    fn get_pointer(&self) -> Option<&String> {
        self.pointer.map(|p| unsafe { &*p })
    }
}

fn main() {
    let data = SelfReferential::new(String::from("hello"));
    println!("Data: {:?}", data.get_pointer());
}

use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};

struct MyFuture {
    data: String,
}

impl Future for MyFuture {
    type Output = ();

    fn poll(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<Self::Output> {
        // self is pinned, cannot move
        println!("Polling with data: {}", self.data);
        Poll::Ready(())
    }
}

async fn use_future() {
    let future = MyFuture {
        data: String::from("async"),
    };
    future.await;
}

#[tokio::main]
async fn main() {
    use_future().await;
}

trait LendingIterator {
    type Item<'a> where Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>>;
}

struct WindowsMut<'data, T> {
    slice: &'data mut [T],
    window_size: usize,
    position: usize,
}

impl<'data, T> LendingIterator for WindowsMut<'data, T> {
    type Item<'a> = &'a mut [T] where Self: 'a;

    fn next<'a>(&'a mut self) -> Option<Self::Item<'a>> {
        if self.position + self.window_size > self.slice.len() {
            return None;
        }

        let start = self.position;
        let end = start + self.window_size;
        self.position += 1;

        // SAFETY: We return non-overlapping windows
        unsafe {
            let ptr = self.slice.as_mut_ptr();
            Some(std::slice::from_raw_parts_mut(
                ptr.add(start),
                self.window_size,
            ))
        }
    }
}

fn main() {
    let mut data = vec![1, 2, 3, 4, 5];
    let mut windows = WindowsMut {
        slice: &mut data,
        window_size: 3,
        position: 0,
    };

    while let Some(window) = windows.next() {
        println!("{:?}", window);
    }
}

trait Container {
    type Inner<T>;

    fn wrap<T>(value: T) -> Self::Inner<T>;
    fn unwrap<T>(container: Self::Inner<T>) -> T;
}

struct VecContainer;

impl Container for VecContainer {
    type Inner<T> = Vec<T>;

    fn wrap<T>(value: T) -> Vec<T> {
        vec![value]
    }

    fn unwrap<T>(mut container: Vec<T>) -> T {
        container.pop().expect("Empty vector")
    }
}

fn main() {
    let wrapped = VecContainer::wrap(42);
    let unwrapped = VecContainer::unwrap(wrapped);
    println!("{}", unwrapped);
}

// This doesn't work - cannot have cyclic references
struct Node {
    value: i32,
    neighbors: Vec<Box<Node>>, // Each node owns its neighbors
    // But neighbors also need to point back!
}

use typed_arena::Arena;
use std::cell::Cell;

struct Node<'a> {
    value: i32,
    neighbors: Cell<Vec<&'a Node<'a>>>,
}

impl<'a> Node<'a> {
    fn new(value: i32, arena: &'a Arena<Node<'a>>) -> &'a Node<'a> {
        arena.alloc(Node {
            value,
            neighbors: Cell::new(Vec::new()),
        })
    }

    fn add_edge(&self, neighbor: &'a Node<'a>) {
        let mut neighbors = self.neighbors.take();
        neighbors.push(neighbor);
        self.neighbors.set(neighbors);
    }
}

fn main() {
    let arena = Arena::new();

    // Create nodes
    let node1 = Node::new(1, &arena);
    let node2 = Node::new(2, &arena);
    let node3 = Node::new(3, &arena);

    // Build graph with cycles
    node1.add_edge(node2);
    node2.add_edge(node3);
    node3.add_edge(node1); // Cycle!

    println!("Graph built successfully");
    // Arena deallocates everything at once
}

use std::collections::HashMap;

#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
struct NodeId {
    index: usize,
    generation: u64,
}

struct Node {
    value: i32,
    neighbors: Vec<NodeId>,
}

struct Graph {
    nodes: HashMap<NodeId, Node>,
    next_index: usize,
    generation: u64,
}

impl Graph {
    fn new() -> Self {
        Self {
            nodes: HashMap::new(),
            next_index: 0,
            generation: 0,
        }
    }

    fn add_node(&mut self, value: i32) -> NodeId {
        let id = NodeId {
            index: self.next_index,
            generation: self.generation,
        };

        self.nodes.insert(id, Node {
            value,
            neighbors: Vec::new(),
        });

        self.next_index += 1;
        id
    }

    fn add_edge(&mut self, from: NodeId, to: NodeId) {
        if let Some(node) = self.nodes.get_mut(&from) {
            node.neighbors.push(to);
        }
    }

    fn remove_node(&mut self, id: NodeId) {
        self.nodes.remove(&id);
        self.generation += 1; // Invalidate old references
    }

    fn get_node(&self, id: NodeId) -> Option<&Node> {
        self.nodes.get(&id)
    }
}

fn main() {
    let mut graph = Graph::new();

    let n1 = graph.add_node(1);
    let n2 = graph.add_node(2);
    let n3 = graph.add_node(3);

    graph.add_edge(n1, n2);
    graph.add_edge(n2, n3);
    graph.add_edge(n3, n1); // Cycle is fine!

    println!("Node 1: {:?}", graph.get_node(n1));
}

use slotmap::{SlotMap, DefaultKey};

struct Node {
    value: i32,
    neighbors: Vec<DefaultKey>,
}

struct Graph {
    nodes: SlotMap<DefaultKey, Node>,
}

impl Graph {
    fn new() -> Self {
        Self {
            nodes: SlotMap::new(),
        }
    }

    fn add_node(&mut self, value: i32) -> DefaultKey {
        self.nodes.insert(Node {
            value,
            neighbors: Vec::new(),
        })
    }

    fn add_edge(&mut self, from: DefaultKey, to: DefaultKey) {
        if let Some(node) = self.nodes.get_mut(from) {
            node.neighbors.push(to);
        }
    }

    fn traverse(&self, start: DefaultKey) {
        let mut visited = std::collections::HashSet::new();
        let mut stack = vec![start];

        while let Some(id) = stack.pop() {
            if !visited.insert(id) {
                continue;
            }

            if let Some(node) = self.nodes.get(id) {
                println!("Visiting: {}", node.value);
                stack.extend(&node.neighbors);
            }
        }
    }
}

fn main() {
    let mut graph = Graph::new();

    let n1 = graph.add_node(1);
    let n2 = graph.add_node(2);
    let n3 = graph.add_node(3);

    graph.add_edge(n1, n2);
    graph.add_edge(n2, n3);
    graph.add_edge(n3, n1);

    graph.traverse(n1);
}

use std::rc::{Rc, Weak};
use std::cell::RefCell;

trait Observer {
    fn notify(&self, message: &str);
}

struct Subject {
    observers: RefCell<Vec<Weak<dyn Observer>>>,
}

impl Subject {
    fn new() -> Self {
        Self {
            observers: RefCell::new(Vec::new()),
        }
    }

    fn subscribe(&self, observer: Weak<dyn Observer>) {
        self.observers.borrow_mut().push(observer);
    }

    fn notify_all(&self, message: &str) {
        // Clean up dead references while notifying
        self.observers.borrow_mut().retain(|weak| {
            if let Some(observer) = weak.upgrade() {
                observer.notify(message);
                true
            } else {
                false // Remove dead weak reference
            }
        });
    }
}

struct ConcreteObserver {
    id: u32,
}

impl Observer for ConcreteObserver {
    fn notify(&self, message: &str) {
        println!("Observer {} received: {}", self.id, message);
    }
}

fn main() {
    let subject = Subject::new();

    {
        let observer1 = Rc::new(ConcreteObserver { id: 1 });
        let observer2 = Rc::new(ConcreteObserver { id: 2 });

        subject.subscribe(Rc::downgrade(&observer1));
        subject.subscribe(Rc::downgrade(&observer2));

        subject.notify_all("Event 1");
        // observer1 and observer2 alive here
    }

    // Observers dropped, weak references now dead
    subject.notify_all("Event 2"); // No output
}

use tokio::sync::broadcast;

struct EventBus {
    sender: broadcast::Sender<String>,
}

impl EventBus {
    fn new() -> Self {
        let (sender, _) = broadcast::channel(100);
        Self { sender }
    }

    fn subscribe(&self) -> broadcast::Receiver<String> {
        self.sender.subscribe()
    }

    fn publish(&self, message: String) {
        let _ = self.sender.send(message);
    }
}

#[tokio::main]
async fn main() {
    let bus = EventBus::new();

    let mut rx1 = bus.subscribe();
    let mut rx2 = bus.subscribe();

    tokio::spawn(async move {
        while let Ok(msg) = rx1.recv().await {
            println!("Observer 1: {}", msg);
        }
    });

    tokio::spawn(async move {
        while let Ok(msg) = rx2.recv().await {
            println!("Observer 2: {}", msg);
        }
    });

    bus.publish("Event 1".to_string());
    bus.publish("Event 2".to_string());

    tokio::time::sleep(tokio::time::Duration::from_millis(100)).await;
}

trait Plugin: Send + Sync {
    fn name(&self) -> &str;
    fn execute(&self, input: &str) -> String;
}

struct PluginRegistry {
    plugins: Vec<Box<dyn Plugin>>,
}

impl PluginRegistry {
    fn new() -> Self {
        Self {
            plugins: Vec::new(),
        }
    }

    fn register(&mut self, plugin: Box<dyn Plugin>) {
        println!("Registered plugin: {}", plugin.name());
        self.plugins.push(plugin);
    }

    fn execute_all(&self, input: &str) {
        for plugin in &self.plugins {
            let result = plugin.execute(input);
            println!("{}: {}", plugin.name(), result);
        }
    }
}

struct UppercasePlugin;

impl Plugin for UppercasePlugin {
    fn name(&self) -> &str {
        "Uppercase"
    }

    fn execute(&self, input: &str) -> String {
        input.to_uppercase()
    }
}

struct ReversePlugin;

impl Plugin for ReversePlugin {
    fn name(&self) -> &str {
        "Reverse"
    }

    fn execute(&self, input: &str) -> String {
        input.chars().rev().collect()
    }
}

fn main() {
    let mut registry = PluginRegistry::new();

    registry.register(Box::new(UppercasePlugin));
    registry.register(Box::new(ReversePlugin));

    registry.execute_all("hello");
}

use std::any::Any;
use std::collections::HashMap;

trait PluginFactory: Send + Sync {
    fn create(&self) -> Box<dyn Any + Send>;
}

struct PluginManager {
    factories: HashMap<String, Box<dyn PluginFactory>>,
}

impl PluginManager {
    fn new() -> Self {
        Self {
            factories: HashMap::new(),
        }
    }

    fn register<F>(&mut self, name: String, factory: F)
    where
        F: PluginFactory + 'static,
    {
        self.factories.insert(name, Box::new(factory));
    }

    fn create_plugin(&self, name: &str) -> Option<Box<dyn Any + Send>> {
        self.factories.get(name).map(|f| f.create())
    }
}

struct StringProcessorFactory;

impl PluginFactory for StringProcessorFactory {
    fn create(&self) -> Box<dyn Any + Send> {
        Box::new("StringProcessor".to_string())
    }
}

fn main() {
    let mut manager = PluginManager::new();
    manager.register("processor".to_string(), StringProcessorFactory);

    if let Some(plugin) = manager.create_plugin("processor") {
        if let Some(processor) = plugin.downcast_ref::<String>() {
            println!("Created: {}", processor);
        }
    }
}

use std::collections::HashMap;

type Handler = Box<dyn Fn(&Request) -> Response + Send + Sync>;

struct Request {
    path: String,
    method: String,
}

struct Response {
    status: u16,
    body: String,
}

struct Router {
    routes: HashMap<(String, String), Handler>,
}

impl Router {
    fn new() -> Self {
        Self {
            routes: HashMap::new(),
        }
    }

    fn route<F>(&mut self, method: &str, path: &str, handler: F)
    where
        F: Fn(&Request) -> Response + Send + Sync + 'static,
    {
        self.routes.insert(
            (method.to_string(), path.to_string()),
            Box::new(handler),
        );
    }

    fn handle(&self, request: &Request) -> Response {
        let key = (request.method.clone(), request.path.clone());

        if let Some(handler) = self.routes.get(&key) {
            handler(request)
        } else {
            Response {
                status: 404,
                body: "Not Found".to_string(),
            }
        }
    }
}

fn main() {
    let mut router = Router::new();

    // Closures capture their environment
    let greeting = "Hello".to_string();

    router.route("GET", "/hello", move |_req| Response {
        status: 200,
        body: format!("{}, World!", greeting), // Moved into closure
    });

    router.route("POST", "/echo", |req| Response {
        status: 200,
        body: req.path.clone(),
    });

    let req = Request {
        path: "/hello".to_string(),
        method: "GET".to_string(),
    };

    let res = router.handle(&req);
    println!("Status: {}, Body: {}", res.status, res.body);
}

fn main() {
    let data = vec![1, 2, 3];
    let ptr = data.as_ptr();

    // Convention 1: Pointer does not own data
    // data still owns the Vec
    unsafe {
        println!("First element: {}", *ptr);
    }

    // Convention 2: Transfer ownership via raw pointer
    let boxed = Box::new(42);
    let raw = Box::into_raw(boxed); // Ownership transferred

    // Must manually free
    unsafe {
        let _reclaimed = Box::from_raw(raw); // Ownership restored
    } // Dropped here
}

use std::ptr;

struct Node<T> {
    value: T,
    next: Option<Box<Node<T>>>,
}

struct LinkedList<T> {
    head: Option<Box<Node<T>>>,
}

impl<T> LinkedList<T> {
    fn new() -> Self {
        Self { head: None }
    }

    fn push(&mut self, value: T) {
        let new_node = Box::new(Node {
            value,
            next: self.head.take(),
        });
        self.head = Some(new_node);
    }

    fn pop(&mut self) -> Option<T> {
        self.head.take().map(|node| {
            self.head = node.next;
            node.value
        })
    }

    // Unsafe peek implementation
    fn peek_raw(&self) -> Option<*const T> {
        self.head.as_ref().map(|node| {
            &node.value as *const T
        })
    }
}

fn main() {
    let mut list = LinkedList::new();
    list.push(1);
    list.push(2);
    list.push(3);

    if let Some(ptr) = list.peek_raw() {
        unsafe {
            println!("Peeked: {}", *ptr);
        }
    }

    while let Some(value) = list.pop() {
        println!("{}", value);
    }
}

use std::alloc::{alloc, dealloc, Layout};
use std::ptr;

struct MyVec<T> {
    ptr: *mut T,
    len: usize,
    capacity: usize,
}

impl<T> MyVec<T> {
    fn new() -> Self {
        Self {
            ptr: ptr::null_mut(),
            len: 0,
            capacity: 0,
        }
    }

    fn push(&mut self, value: T) {
        if self.len == self.capacity {
            self.grow();
        }

        unsafe {
            ptr::write(self.ptr.add(self.len), value);
        }
        self.len += 1;
    }

    fn pop(&mut self) -> Option<T> {
        if self.len == 0 {
            None
        } else {
            self.len -= 1;
            unsafe {
                Some(ptr::read(self.ptr.add(self.len)))
            }
        }
    }

    fn grow(&mut self) {
        let new_capacity = if self.capacity == 0 {
            1
        } else {
            self.capacity * 2
        };

        let new_layout = Layout::array::<T>(new_capacity).unwrap();

        let new_ptr = if self.capacity == 0 {
            unsafe { alloc(new_layout) as *mut T }
        } else {
            let old_layout = Layout::array::<T>(self.capacity).unwrap();
            unsafe {
                std::alloc::realloc(
                    self.ptr as *mut u8,
                    old_layout,
                    new_layout.size(),
                ) as *mut T
            }
        };

        self.ptr = new_ptr;
        self.capacity = new_capacity;
    }
}

impl<T> Drop for MyVec<T> {
    fn drop(&mut self) {
        if self.capacity != 0 {
            // Drop elements
            while let Some(_) = self.pop() {}

            // Deallocate memory
            let layout = Layout::array::<T>(self.capacity).unwrap();
            unsafe {
                dealloc(self.ptr as *mut u8, layout);
            }
        }
    }
}

fn main() {
    let mut vec = MyVec::new();
    vec.push(1);
    vec.push(2);
    vec.push(3);

    println!("{:?}", vec.pop()); // Some(3)
    println!("{:?}", vec.pop()); // Some(2)
}