Rust's Ownership Model: The Key to Safer, More Efficient Algorithms

fn demonstrate_ownership_transfer() {
// s1 owns a String allocated on the heaplet s1 = String::from("Hello, RantAI!");
    println!("Original owner s1: {}", s1);

// Ownership transfer: s1 -> s2let s2 = s1;
// s1 is now invalid! The compiler prevents use-after-move.

    println!("New owner s2: {}", s2);
// Uncommenting the next line would cause a compile error:// println!("Invalid access to s1: {}", s1); // ❌ Error: value borrowed here after move
}

fn compare_copy_vs_move() {
// Copy types (like integers) are copied, not movedlet x = 42;
    let y = x;// x is copied to yprintln!("Both x ({}) and y ({}) are still valid", x, y);// ✅ Works fine

// Heap-allocated types are movedlet vec1 = vec![1, 2, 3, 4, 5];
    let vec2 = vec1;// vec1 is moved to vec2println!("vec2: {:?}", vec2);
// println!("vec1: {:?}", vec1); // ❌ Would cause compile error
}

fn main() {
    demonstrate_ownership_transfer();
    compare_copy_vs_move();
}

fn demonstrate_cloning() {
    let original = String::from("RantAI's ownership guide");

// Explicit cloning creates a new heap allocationlet cloned = original.clone();

// Now both are valid and independentprintln!("Original: {}", original);
    println!("Clone: {}", cloned);

// Demonstrate independence by modifying onelet mut modified_clone = cloned;
    modified_clone.push_str(" - Enhanced Edition");
    println!("Modified clone: {}", modified_clone);
    println!("Original unchanged: {}", original);
}

// Immutable borrowing examplefn analyze_data(data: &Vec<i32>) -> (usize, i32, f64) {
    let len = data.len();
    let sum: i32 = data.iter().sum();
    let average = sum as f64 / len as f64;
    (len, sum, average)
}// Reference goes out of scope, but data remains owned by caller// Mutable borrowing examplefn normalize_data(data: &mut Vec<f64>, max_value: f64) {
    for value in data.iter_mut() {
        *value = *value / max_value;
    }
}// Mutable reference goes out of scope, ownership returns to callerfn demonstrate_borrowing_rules() {
    let mut numbers = vec![1.0, 2.0, 3.0, 4.0, 5.0];

// Multiple immutable borrows are allowedlet analysis1 = analyze_data(&vec![1, 2, 3, 4, 5]);
    let analysis2 = analyze_data(&vec![6, 7, 8, 9, 10]);
    println!("Analysis 1: {:?}", analysis1);
    println!("Analysis 2: {:?}", analysis2);

// One mutable borrow at a timelet max_val = 5.0;
    normalize_data(&mut numbers, max_val);
    println!("Normalized: {:?}", numbers);

// After mutable borrow ends, we can borrow immutably againprintln!("Final length: {}", numbers.len());
}

// Advanced: Borrowing with function compositionfn process_scientific_data(raw_data: &[f64]) -> Vec<f64> {
    raw_data.iter()
        .filter(|&&x| x > 0.0)// Remove invalid readings
        .map(|&x| x.sqrt())// Apply transformation
        .collect()// Collect into new Vec// raw_data remains unchanged and owned by caller
}

fn main() {
    demonstrate_borrowing_rules();

    let sensor_readings = vec![4.0, 9.0, -1.0, 16.0, 0.0, 25.0];
    let processed = process_scientific_data(&sensor_readings);

// Both original and processed data are availableprintln!("Original readings: {:?}", sensor_readings);
    println!("Processed readings: {:?}", processed);
}

// Example 1: Basic lifetime violation (won't compile)fn lifetime_violation_example() {
    let reference_to_nothing;
    {
        let my_local_string = String::from("I live a short life");
// ERROR: `my_local_string` does not live long enough// reference_to_nothing = &my_local_string;
    }// `my_local_string` is dropped here

// If the above assignment were allowed, `reference_to_nothing` would be dangling// println!("{}", reference_to_nothing); // ❌ Use after free!
}

// Example 2: Explicit lifetime annotationsfn longest_string<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() {
        x
    } else {
        y
    }
// Return value lives as long as the shorter of the two input lifetimes
}

// Example 3: Lifetime in structs - ensuring references remain validstruct DataAnalyzer<'a> {
    dataset: &'a [f64],
    name: &'a str,
}

impl<'a> DataAnalyzer<'a> {
    fn new(dataset: &'a [f64], name: &'a str) -> Self {
        DataAnalyzer { dataset, name }
    }

    fn compute_statistics(&self) -> (f64, f64, f64) {
        let sum: f64 = self.dataset.iter().sum();
        let count = self.dataset.len() as f64;
        let mean = sum / count;

        let variance: f64 = self.dataset.iter()
            .map(|x| (x - mean).powi(2))
            .sum::<f64>() / count;

        let std_dev = variance.sqrt();

        (mean, variance, std_dev)
    }
}

fn demonstrate_lifetimes() {
// Lifetime inference works automatically in most caseslet string1 = String::from("RantAI");
    let string2 = String::from("Rust ownership model");

    let longer = longest_string(&string1, &string2);
    println!("Longer string: {}", longer);

// Struct with lifetime parameterslet data = vec![1.5, 2.3, 3.7, 4.1, 2.8, 5.2, 1.9, 3.4];
    let analyzer_name = "Climate Data";

    let analyzer = DataAnalyzer::new(&data, analyzer_name);
    let (mean, variance, std_dev) = analyzer.compute_statistics();

    println!("{}: μ={:.2}, σ²={:.2}, σ={:.2}",
             analyzer.name, mean, variance, std_dev);

}// All borrows end here, ensuring no dangling references

use std::rc::Rc;
use std::cell::RefCell;
use std::sync::{Arc, Mutex};
use std::thread;

// Rc<T>: Reference Counted pointers for shared ownership (single-threaded)fn demonstrate_shared_ownership() {
    #[derive(Debug)]
    struct Node {
        value: i32,
        children: Vec<Rc<Node>>,
    }

    let leaf1 = Rc::new(Node { value: 1, children: vec![] });
    let leaf2 = Rc::new(Node { value: 2, children: vec![] });

// Multiple parents can own the same childlet branch = Rc::new(Node {
        value: 10,
        children: vec![Rc::clone(&leaf1), Rc::clone(&leaf2)]
    });

    let root = Rc::new(Node {
        value: 100,
        children: vec![Rc::clone(&branch), Rc::clone(&leaf1)]
    });

    println!("leaf1 reference count: {}", Rc::strong_count(&leaf1));// 3println!("Root node: {:?}", root);
}

// Arc<T>: Atomic Reference Counted pointers for thread-safe shared ownershipfn demonstrate_concurrent_ownership() {
    let shared_data = Arc::new(Mutex::new(vec![1, 2, 3, 4, 5]));
    let mut handles = vec![];

    for i in 0..3 {
        let data_clone = Arc::clone(&shared_data);
        let handle = thread::spawn(move || {
            let mut data = data_clone.lock().unwrap();
            data.push(i * 10);
            println!("Thread {} added {}", i, i * 10);
        });
        handles.push(handle);
    }

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

    println!("Final data: {:?}", shared_data.lock().unwrap());
}

use std::fs::File;
use std::io::{self, Read, Write};

// Custom RAII wrapper for automatic resource cleanupstruct FileManager {
    file: File,
    path: String,
}

impl FileManager {
    fn new(path: &str) -> io::Result<Self> {
        let file = File::create(path)?;
        Ok(FileManager {
            file,
            path: path.to_string(),
        })
    }

    fn write_data(&mut self, data: &[u8]) -> io::Result<()> {
        self.file.write_all(data)?;
        self.file.sync_all()// Ensure data is written to disk
    }
}

impl Drop for FileManager {
    fn drop(&mut self) {
        println!("Cleaning up file: {}", self.path);
// File is automatically closed when FileManager is dropped// Additional cleanup logic could go here
    }
}

// Ownership ensures automatic cleanupfn demonstrate_raii() -> io::Result<()> {
    {
        let mut manager = FileManager::new("/tmp/rantai_demo.txt")?;
        manager.write_data(b"RantAI ownership demonstration")?;
        println!("Data written successfully");
    }// FileManager dropped here, file automatically closed and cleaned up

    println!("File operations completed");
    Ok(())
}

// Scientific simulation configuration using the builder pattern#[derive(Debug)]
struct SimulationConfig {
    duration: f64,
    time_step: f64,
    particles: usize,
    temperature: f64,
    output_file: String,
}

struct SimulationBuilder {
    duration: Option<f64>,
    time_step: Option<f64>,
    particles: Option<usize>,
    temperature: Option<f64>,
    output_file: Option<String>,
}

impl SimulationBuilder {
    fn new() -> Self {
        SimulationBuilder {
            duration: None,
            time_step: None,
            particles: None,
            temperature: None,
            output_file: None,
        }
    }

// Each method consumes self and returns Self (ownership transfer)fn duration(mut self, duration: f64) -> Self {
        self.duration = Some(duration);
        self
    }

    fn time_step(mut self, step: f64) -> Self {
        self.time_step = Some(step);
        self
    }

    fn particles(mut self, count: usize) -> Self {
        self.particles = Some(count);
        self
    }

    fn temperature(mut self, temp: f64) -> Self {
        self.temperature = Some(temp);
        self
    }

    fn output_file(mut self, path: String) -> Self {
        self.output_file = Some(path);
        self
    }

    fn build(self) -> Result<SimulationConfig, &'static str> {
        Ok(SimulationConfig {
            duration: self.duration.ok_or("Duration not specified")?,
            time_step: self.time_step.ok_or("Time step not specified")?,
            particles: self.particles.ok_or("Particle count not specified")?,
            temperature: self.temperature.unwrap_or(300.0),// Default value
            output_file: self.output_file.unwrap_or_else(|| "output.dat".to_string()),
        })
    }
}

fn demonstrate_builder_pattern() {
    let config = SimulationBuilder::new()
        .duration(100.0)
        .time_step(0.001)
        .particles(10000)
        .temperature(273.15)
        .output_file("molecular_dynamics.dat".to_string())
        .build()
        .expect("Failed to build simulation config");

    println!("Simulation configured: {:?}", config);
}

// Iterator chains that compile to optimal assembly codefn demonstrate_zero_cost_abstractions() {
    let sensor_data: Vec<f64> = (0..1000)
        .map(|i| (i as f64 * 0.1).sin() * 100.0 + (i as f64 * 0.05).cos() * 50.0)
        .collect();

// Complex data processing pipeline - compiles to highly optimized codelet processed_results: Vec<_> = sensor_data
        .iter()// Zero-cost iterator
        .enumerate()// Add indices
        .filter(|(i, &value)| {// Filter outliers
            *i > 50 && value.abs() < 120.0
        })
        .map(|(i, &value)| {// Apply calibration
            (i, value * 1.05 + 2.3)
        })
        .filter(|(_, value)| *value > 0.0)// Remove negative readings
        .map(|(i, value)| {// Convert to scientific units
            (i, value / 9.81)// Convert to g-force
        })
        .collect();

    println!("Processed {} readings into {} valid measurements",
             sensor_data.len(), processed_results.len());

    if let Some((last_index, last_value)) = processed_results.last() {
        println!("Last measurement: index {}, value {:.3} g", last_index, last_value);
    }
}

fn main() {
    demonstrate_shared_ownership();
    demonstrate_concurrent_ownership();
    demonstrate_raii().unwrap();
    demonstrate_builder_pattern();
    demonstrate_zero_cost_abstractions();
}

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

// Binary Tree with safe ownership#[derive(Debug)]
struct TreeNode<T> {
    value: T,
    left: Option<Box<TreeNode<T>>>,
    right: Option<Box<TreeNode<T>>>,
}

impl<T: Ord> TreeNode<T> {
    fn new(value: T) -> Self {
        TreeNode {
            value,
            left: None,
            right: None,
        }
    }

    fn insert(&mut self, value: T) {
        if value <= self.value {
            match &mut self.left {
                None => self.left = Some(Box::new(TreeNode::new(value))),
                Some(left) => left.insert(value),
            }
        } else {
            match &mut self.right {
                None => self.right = Some(Box::new(TreeNode::new(value))),
                Some(right) => right.insert(value),
            }
        }
    }

    fn find(&self, value: &T) -> bool {
        if value == &self.value {
            true
        } else if value < &self.value {
            self.left.as_ref().map_or(false, |left| left.find(value))
        } else {
            self.right.as_ref().map_or(false, |right| right.find(value))
        }
    }
}

// Graph with cycles using Rc<RefCell<>> for shared ownershiptype NodeRef<T> = Rc<RefCell<GraphNode<T>>>;
type WeakNodeRef<T> = Weak<RefCell<GraphNode<T>>>;

#[derive(Debug)]
struct GraphNode<T> {
    value: T,
    neighbors: Vec<NodeRef<T>>,
    parent: Option<WeakNodeRef<T>>,// Weak reference to prevent cycles
}

impl<T> GraphNode<T> {
    fn new(value: T) -> NodeRef<T> {
        Rc::new(RefCell::new(GraphNode {
            value,
            neighbors: Vec::new(),
            parent: None,
        }))
    }

    fn add_neighbor(node: &NodeRef<T>, neighbor: NodeRef<T>) {
        node.borrow_mut().neighbors.push(neighbor);
    }

    fn traverse_breadth_first<F>(start: &NodeRef<T>, mut visit: F)
    where F: FnMut(&T) {
        use std::collections::{VecDeque, HashSet};
        use std::ptr;

        let mut queue = VecDeque::new();
        let mut visited = HashSet::new();

        queue.push_back(Rc::clone(start));

        while let Some(current) = queue.pop_front() {
            let ptr = Rc::as_ptr(&current);

            if visited.insert(ptr) {
                visit(&current.borrow().value);

                for neighbor in &current.borrow().neighbors {
                    queue.push_back(Rc::clone(neighbor));
                }
            }
        }
    }
}

fn demonstrate_data_structures() {
// Binary tree usagelet mut tree = TreeNode::new(50);
    tree.insert(30);
    tree.insert(70);
    tree.insert(20);
    tree.insert(40);
    tree.insert(60);
    tree.insert(80);

    println!("Tree contains 40: {}", tree.find(&40));
    println!("Tree contains 45: {}", tree.find(&45));

// Graph usagelet node_a = GraphNode::new("A");
    let node_b = GraphNode::new("B");
    let node_c = GraphNode::new("C");

    GraphNode::add_neighbor(&node_a, Rc::clone(&node_b));
    GraphNode::add_neighbor(&node_a, Rc::clone(&node_c));
    GraphNode::add_neighbor(&node_b, Rc::clone(&node_c));

    println!("Graph traversal starting from A:");
    GraphNode::traverse_breadth_first(&node_a, |value| println!("  Visiting: {}", value));
}

use std::collections::HashMap;

// Different ownership patterns for different use casesstruct DataProcessor {
    cache: HashMap<String, Vec<f64>>,
    processing_config: ProcessingConfig,
}

#[derive(Clone)]
struct ProcessingConfig {
    sampling_rate: f64,
    filter_threshold: f64,
    output_format: String,
}

impl DataProcessor {
    fn new(config: ProcessingConfig) -> Self {
        DataProcessor {
            cache: HashMap::new(),
            processing_config: config,// Takes ownership - config is consumed
        }
    }

// Consuming method - takes ownership, transforms and returns new instancefn with_updated_config(mut self, new_config: ProcessingConfig) -> Self {
        self.processing_config = new_config;
        self
    }

// Immutable borrow - read-only accessfn get_cached_data(&self, key: &str) -> Option<&Vec<f64>> {
        self.cache.get(key)
    }

// Mutable borrow - can modify internal statefn process_and_cache(&mut self, key: String, raw_data: &[f64]) -> &Vec<f64> {
        let processed = raw_data.iter()
            .filter(|&&x| x > self.processing_config.filter_threshold)
            .map(|&x| x * self.processing_config.sampling_rate)
            .collect();

        self.cache.insert(key.clone(), processed);
        self.cache.get(&key).unwrap()
    }

// Returns owned data - caller gets full ownershipfn extract_processed_data(self, key: &str) -> Option<Vec<f64>> {
        self.cache.into_iter()
            .find(|(k, _)| k == key)
            .map(|(_, v)| v)
    }

// Shared reference with specific lifetimefn analyze_data<'a>(&'a self, datasets: &'a [&str]) -> DataAnalysis<'a> {
        DataAnalysis {
            processor: self,
            datasets,
            total_points: datasets.iter()
                .filter_map(|&key| self.cache.get(key))
                .map(|data| data.len())
                .sum(),
        }
    }
}

// Struct with lifetime parameter ensures references remain validstruct DataAnalysis<'a> {
    processor: &'a DataProcessor,
    datasets: &'a [&'a str],
    total_points: usize,
}

impl<'a> DataAnalysis<'a> {
    fn compute_statistics(&self) -> (f64, f64) {
        let all_values: Vec<f64> = self.datasets.iter()
            .filter_map(|&key| self.processor.cache.get(key))
            .flat_map(|data| data.iter())
            .copied()
            .collect();

        if all_values.is_empty() {
            return (0.0, 0.0);
        }

        let mean = all_values.iter().sum::<f64>() / all_values.len() as f64;
        let variance = all_values.iter()
            .map(|x| (x - mean).powi(2))
            .sum::<f64>() / all_values.len() as f64;

        (mean, variance.sqrt())
    }
}

fn demonstrate_api_design() {
    let config = ProcessingConfig {
        sampling_rate: 1.5,
        filter_threshold: 0.1,
        output_format: "CSV".to_string(),
    };

    let mut processor = DataProcessor::new(config);

// Process some sample datalet raw_sensor_data = vec![0.05, 0.15, 0.25, 0.35, 0.45];
    processor.process_and_cache("sensor_1".to_string(), &raw_sensor_data);

    let raw_temp_data = vec![20.1, 21.5, 19.8, 22.3, 20.9];
    processor.process_and_cache("temp_1".to_string(), &raw_temp_data);

// Analyze the cached datalet datasets = ["sensor_1", "temp_1"];
    let analysis = processor.analyze_data(&datasets);
    let (mean, std_dev) = analysis.compute_statistics();

    println!("Analysis: {} total points, mean: {:.3}, std_dev: {:.3}",
             analysis.total_points, mean, std_dev);

// Extract ownership of specific datasetlet extracted = processor.extract_processed_data("sensor_1");
    println!("Extracted data: {:?}", extracted);
}

// Common beginner struggle: trying to hold multiple mutable referencesfn inefficient_approach() {
    let mut data = vec![1, 2, 3, 4, 5];

// This doesn't work - multiple mutable borrows// let slice1 = &mut data[0..2];// let slice2 = &mut data[2..5];  // Error: cannot borrow data as mutable more than once

// Beginner workaround: clone everything (inefficient)let mut data1 = data[0..2].to_vec();
    let mut data2 = data[2..5].to_vec();

// Process separately
    data1.iter_mut().for_each(|x| *x *= 2);
    data2.iter_mut().for_each(|x| *x *= 3);

    println!("Inefficient result: {:?}, {:?}", data1, data2);
}

// Rust-idiomatic approach: use split_at_mut for safe simultaneous accessfn efficient_approach() {
    let mut data = vec![1, 2, 3, 4, 5];

// Split into two non-overlapping mutable sliceslet (left, right) = data.split_at_mut(2);

// Now we can mutate both halves simultaneously
    left.iter_mut().for_each(|x| *x *= 2);
    right.iter_mut().for_each(|x| *x *= 3);

    println!("Efficient result: {:?}", data);
}

// Advanced: parallel processing with ownershipfn parallel_processing_with_ownership() {
    use std::thread;

    let data: Vec<i32> = (0..1000).collect();
    let chunk_size = data.len() / 4;

// Split data into owned chunks for parallel processinglet chunks: Vec<Vec<i32>> = data.chunks(chunk_size)
        .map(|chunk| chunk.to_vec())
        .collect();

// Process chunks in parallel threadslet handles: Vec<_> = chunks.into_iter()
        .enumerate()
        .map(|(i, chunk)| {
            thread::spawn(move || {
                let processed: Vec<i32> = chunk.iter()
                    .map(|&x| x * x + i as i32)
                    .collect();
                (i, processed)
            })
        })
        .collect();

// Collect resultslet mut results: Vec<(usize, Vec<i32>)> = handles.into_iter()
        .map(|handle| handle.join().unwrap())
        .collect();

    results.sort_by_key(|(i, _)| *i);

    let final_result: Vec<i32> = results.into_iter()
        .flat_map(|(_, chunk)| chunk)
        .collect();

    println!("Parallel processing completed: {} elements processed", final_result.len());
}

fn main() {
    demonstrate_data_structures();
    demonstrate_api_design();
    inefficient_approach();
    efficient_approach();
    parallel_processing_with_ownership();
}

use std::time::Instant;

// Comparison: Manual memory management simulation vs Rust ownershipfn demonstrate_performance_benefits() {
    const ITERATIONS: usize = 100_000;
    const DATA_SIZE: usize = 1000;

// Rust's zero-cost abstraction with ownershipfn rust_approach() -> Vec<f64> {
        (0..DATA_SIZE)
            .map(|i| i as f64)
            .filter(|&x| x % 2.0 == 0.0)
            .map(|x| x * x)
            .collect()
    }

// Simulating manual allocation patterns (what you'd do in C/C++)fn manual_approach() -> Vec<f64> {
        let mut temp1 = Vec::with_capacity(DATA_SIZE);
        for i in 0..DATA_SIZE {
            temp1.push(i as f64);
        }

        let mut temp2 = Vec::new();
        for &x in &temp1 {
            if x % 2.0 == 0.0 {
                temp2.push(x);
            }
        }

        let mut result = Vec::new();
        for &x in &temp2 {
            result.push(x * x);
        }

        result
    }

// Benchmark Rust approachlet start = Instant::now();
    for _ in 0..ITERATIONS {
        let _ = rust_approach();
    }
    let rust_time = start.elapsed();

// Benchmark manual approachlet start = Instant::now();
    for _ in 0..ITERATIONS {
        let _ = manual_approach();
    }
    let manual_time = start.elapsed();

    println!("Performance Comparison ({} iterations):", ITERATIONS);
    println!("  Rust ownership approach: {:?}", rust_time);
    println!("  Manual approach: {:?}", manual_time);
    println!("  Rust is {:.2}x faster", manual_time.as_nanos() as f64 / rust_time.as_nanos() as f64);
}

// Memory usage demonstrationfn demonstrate_memory_efficiency() {
// Rust's ownership prevents unnecessary allocationsfn process_large_dataset(data: Vec<f64>) -> Vec<f64> {
        data.into_iter()// Consumes the input vector (no copy)
            .map(|x| x.sqrt())
            .filter(|&x| x > 1.0)
            .collect()
    }

// Create a large datasetlet large_data: Vec<f64> = (0..1_000_000)
        .map(|i| i as f64 * 0.001)
        .collect();

    println!("Original data size: {} elements", large_data.len());

// Process without additional memory allocation for the inputlet processed = process_large_dataset(large_data);
// large_data is no longer accessible - memory was reused efficiently

    println!("Processed data size: {} elements", processed.len());
    println!("Memory efficiency: Input vector was consumed and reused");
}

fn performance_main() {
    demonstrate_performance_benefits();
    demonstrate_memory_efficiency();
}

# Run individual examples
cargo run --bin ownership_basics
cargo run --bin borrowing_examples
cargo run --bin lifetime_examples
cargo run --bin advanced_patterns