Rust's Design Philosophy and Principles: Understanding the Language's Core Values

fn main() {
    // Ownership system ensures memory safety
    let s1 = String::from("hello");
    let s2 = s1; // Ownership moved to s2
    
    // This would cause a compile-time error:
    // println!("{}", s1); // Error: value borrowed after move
    
    // Instead, we can clone if we need two copies
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Deep copy
    
    // Now we can use both
    println!("s1: {}, s2: {}", s1, s2);
    
    // Memory is automatically freed when variables go out of scope
    {
        let s = String::from("scope");
        // s is valid here
    } // s goes out of scope and memory is freed
}

// High-level abstraction: iterators
fn sum_of_squares(numbers: &[i32]) -> i32 {
    numbers.iter()
           .map(|&x| x * x)
           .sum()
}

// Compiles to efficient code similar to:
fn sum_of_squares_manual(numbers: &[i32]) -> i32 {
    let mut sum = 0;
    for i in 0..numbers.len() {
        sum += numbers[i] * numbers[i];
    }
    sum
}

// Both functions have similar performance characteristics
fn main() {
    let numbers = [1, 2, 3, 4, 5];
    assert_eq!(sum_of_squares(&numbers), sum_of_squares_manual(&numbers));
}

fn main() {
    // Exhaustive pattern matching ensures all cases are handled
    enum Result<T, E> {
        Ok(T),
        Err(E),
    }
    
    fn process_result(result: Result<i32, &str>) -> i32 {
        match result {
            Result::Ok(value) => value,
            Result::Err(error) => {
                eprintln!("Error: {}", error);
                0 // Default value
            }
        }
    }
    
    // No null pointer exceptions
    let maybe_value: Option<i32> = Some(42);
    
    // Must explicitly handle the None case
    let value = match maybe_value {
        Some(v) => v,
        None => 0,
    };
    
    println!("Value: {}", value);
}

fn main() {
    // Type inference reduces verbosity
    let numbers = vec![1, 2, 3, 4, 5];
    
    // Powerful standard library
    let sum: i32 = numbers.iter().sum();
    let product: i32 = numbers.iter().product();
    
    // Pattern matching for destructuring
    let point = (10, 20);
    let (x, y) = point;
    
    // Concise error handling with ?
    fn read_file() -> Result<String, std::io::Error> {
        let contents = std::fs::read_to_string("file.txt")?;
        Ok(contents)
    }
    
    // Cargo for dependency management
    // $ cargo add serde --features derive
    // $ cargo build
}

fn main() {
    // Explicit allocations
    let on_stack = [0; 1024]; // 1024 integers on the stack
    let on_heap = vec![0; 1024]; // 1024 integers on the heap
    
    // Explicit copying
    let s1 = String::from("hello");
    let s2 = s1.clone(); // Explicit deep copy
    
    // Explicit mutability
    let mut counter = 0;
    counter += 1; // Must declare as mutable to modify
    
    // Explicit error handling
    let result = std::fs::read_to_string("file.txt");
    match result {
        Ok(contents) => println!("File contents: {}", contents),
        Err(error) => println!("Error reading file: {}", error),
    }
}

fn main() {
    // Strong static typing
    let x: i32 = 42;
    let y: f64 = 3.14;
    
    // This would cause a compile-time error:
    // let z = x + y; // Error: mismatched types
    
    // Explicit conversion required
    let z = x as f64 + y;
    println!("z = {}", z);
    
    // Enums for representing variants
    enum Shape {
        Circle(f64),          // Radius
        Rectangle(f64, f64),  // Width, Height
        Triangle(f64, f64, f64), // Three sides
    }
    
    // Pattern matching ensures all variants are handled
    fn area(shape: Shape) -> f64 {
        match shape {
            Shape::Circle(radius) => std::f64::consts::PI * radius * radius,
            Shape::Rectangle(width, height) => width * height,
            Shape::Triangle(a, b, c) => {
                // Heron's formula
                let s = (a + b + c) / 2.0;
                (s * (s - a) * (s - b) * (s - c)).sqrt()
            }
        }
    }
}

// Define a trait (interface)
trait Animal {
    // Required methods
    fn name(&self) -> &str;
    fn sound(&self) -> &str;
    
    // Default method implementation
    fn speak(&self) {
        println!("{} says {}", self.name(), self.sound());
    }
}

// Implement the trait for a struct
struct Cat {
    name: String,
}

impl Animal for Cat {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn sound(&self) -> &str {
        "meow"
    }
}

struct Dog {
    name: String,
}

impl Animal for Dog {
    fn name(&self) -> &str {
        &self.name
    }
    
    fn sound(&self) -> &str {
        "woof"
    }
    
    // Override the default implementation
    fn speak(&self) {
        println!("{} barks: {}!", self.name(), self.sound());
    }
}

// Generic function using trait bounds
fn make_animal_speak<T: Animal>(animal: &T) {
    animal.speak();
}

fn main() {
    let cat = Cat { name: String::from("Whiskers") };
    let dog = Dog { name: String::from("Rex") };
    
    make_animal_speak(&cat); // Whiskers says meow
    make_animal_speak(&dog); // Rex barks: woof!
}

// Sum type (enum)
enum Result<T, E> {
    Ok(T),
    Err(E),
}

// Product type (struct)
struct Point {
    x: f64,
    y: f64,
}

// Combining sum and product types
enum Shape {
    Circle {
        center: Point,
        radius: f64,
    },
    Rectangle {
        top_left: Point,
        bottom_right: Point,
    },
}

fn main() {
    // Using the algebraic data types
    let result: Result<i32, &str> = Result::Ok(42);
    
    match result {
        Result::Ok(value) => println!("Success: {}", value),
        Result::Err(error) => println!("Error: {}", error),
    }
    
    let circle = Shape::Circle {
        center: Point { x: 0.0, y: 0.0 },
        radius: 5.0,
    };
    
    match circle {
        Shape::Circle { center, radius } => {
            println!("Circle at ({}, {}) with radius {}", center.x, center.y, radius);
        }
        Shape::Rectangle { top_left, bottom_right } => {
            println!("Rectangle from ({}, {}) to ({}, {})",
                     top_left.x, top_left.y, bottom_right.x, bottom_right.y);
        }
    }
}

fn main() {
    let s = String::from("hello");
    
    // Transfer ownership
    let s2 = s;
    
    // This would cause a compile-time error:
    // println!("{}", s); // Error: value used after move
    
    // Borrowing allows multiple references
    let s = String::from("hello");
    
    // Immutable borrow
    let len = calculate_length(&s);
    println!("The length of '{}' is {}.", s, len);
    
    // Mutable borrow (exclusive)
    let mut s = String::from("hello");
    change(&mut s);
    println!("Changed string: {}", s);
}

fn calculate_length(s: &String) -> usize {
    s.len()
}

fn change(s: &mut String) {
    s.push_str(", world");
}

fn main() {
    let mut num = 5;
    
    // Safe Rust doesn't allow raw pointer dereferencing
    let ptr = &mut num as *mut i32;
    
    // Unsafe block for operations that can't be verified by the compiler
    unsafe {
        *ptr = 10;
    }
    
    println!("num: {}", num);
    
    // Example: Implementing a safe abstraction around unsafe code
    struct MyVec<T> {
        ptr: *mut T,
        len: usize,
        capacity: usize,
    }
    
    impl<T> MyVec<T> {
        fn new() -> Self {
            MyVec {
                ptr: std::ptr::null_mut(),
                len: 0,
                capacity: 0,
            }
        }
        
        fn push(&mut self, item: T) {
            if self.len == self.capacity {
                self.grow();
            }
            
            unsafe {
                std::ptr::write(self.ptr.add(self.len), item);
            }
            
            self.len += 1;
        }
        
        fn grow(&mut self) {
            let new_capacity = if self.capacity == 0 { 1 } else { self.capacity * 2 };
            let new_layout = std::alloc::Layout::array::<T>(new_capacity).unwrap();
            
            let new_ptr = if self.capacity == 0 {
                unsafe { std::alloc::alloc(new_layout) as *mut T }
            } else {
                let old_layout = std::alloc::Layout::array::<T>(self.capacity).unwrap();
                let old_ptr = self.ptr as *mut u8;
                unsafe { std::alloc::realloc(old_ptr, old_layout, new_layout.size()) as *mut T }
            };
            
            self.ptr = new_ptr;
            self.capacity = new_capacity;
        }
    }
    
    // The unsafe implementation is hidden behind a safe interface
}

fn main() {
    // Simple cases are simple
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter().sum();
    
    // Complex cases are possible but more verbose
    let result: Result<i32, &str> = Ok(42);
    
    // Pattern matching for control flow
    match result {
        Ok(value) => println!("Success: {}", value),
        Err(error) => println!("Error: {}", error),
    }
    
    // More concise with if let
    if let Ok(value) = result {
        println!("Success: {}", value);
    }
    
    // Functional programming features
    let doubled: Vec<i32> = numbers.iter()
                                  .map(|&x| x * 2)
                                  .filter(|&x| x > 5)
                                  .collect();
    
    println!("Doubled numbers greater than 5: {:?}", doubled);
}

fn main() {
    // Array bounds checking at compile time when possible
    let arr = [1, 2, 3, 4, 5];
    let index = 4;
    
    // Compile-time constant index: checked at compile time
    let value = arr[4]; // Safe
    
    // Variable index: checked at runtime
    let value = arr[index]; // Safe, panics if out of bounds
    
    // Option type for values that might not exist
    fn find_element(arr: &[i32], target: i32) -> Option<usize> {
        for (i, &item) in arr.iter().enumerate() {
            if item == target {
                return Some(i);
            }
        }
        None
    }
    
    // Must handle the None case
    match find_element(&arr, 3) {
        Some(index) => println!("Found at index {}", index),
        None => println!("Not found"),
    }
    
    // Generic code is monomorphized at compile time
    fn max<T: Ord>(a: T, b: T) -> T {
        if a > b { a } else { b }
    }
    
    // These generate different specialized functions
    let max_i32 = max(5, 10);
    let max_f64 = max(5.5, 10.5);
}

// Rust 2015
extern crate serde;
use serde::Serialize;

// Rust 2018
use serde::Serialize;

// Rust 2021
use std::fmt::{Display, Formatter};

// Rust 2024
use std::fmt::{Display, Formatter};
use std::future::Future;

// Stable features are available by default
fn stable_function() {
    let numbers = vec![1, 2, 3];
    let first = numbers.first();
    println!("{:?}", first);
}

// Nightly features require explicit opt-in
#![feature(generic_const_exprs)]
fn array_repeat<T, const N: usize>(value: T) -> [T; N]
where
    T: Copy,
    [(); N]: Sized,
{
    [value; N]
}

fn main() {
    // Immutability by default (from ML family)
    let x = 5;
    // x = 6; // Error: cannot assign twice to immutable variable
    
    // Pattern matching (from ML family)
    let option = Some(42);
    match option {
        Some(value) => println!("Got value: {}", value),
        None => println!("No value"),
    }
    
    // Algebraic data types (from Haskell, ML)
    enum Either<L, R> {
        Left(L),
        Right(R),
    }
    
    // Higher-order functions (from functional languages)
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter().fold(0, |acc, &x| acc + x);
    
    println!("Sum: {}", sum);
}

fn main() {
    // Manual memory management (like C/C++)
    let mut v = Vec::new();
    v.push(1);
    v.push(2);
    v.push(3);
    
    // Drop runs when v goes out of scope
    
    // Zero-cost abstractions (from C++)
    let numbers = vec![1, 2, 3, 4, 5];
    let sum: i32 = numbers.iter().sum(); // Compiles to efficient code
    
    // RAII (Resource Acquisition Is Initialization, from C++)
    struct File {
        handle: std::fs::File,
    }
    
    impl File {
        fn new(path: &str) -> Result<Self, std::io::Error> {
            let handle = std::fs::File::open(path)?;
            Ok(File { handle })
        }
        
        // File is automatically closed when dropped
    }
}

fn main() {
    // Type inference (from languages like Haskell, OCaml)
    let x = 5; // Inferred as i32
    let y = 3.14; // Inferred as f64
    
    // Closures (from many modern languages)
    let add = |a, b| a + b;
    let result = add(5, 10);
    
    // Iterators (from languages like Python, C#)
    let numbers = vec![1, 2, 3, 4, 5];
    let even_numbers: Vec<i32> = numbers.into_iter()
                                       .filter(|x| x % 2 == 0)
                                       .collect();
    
    println!("Even numbers: {:?}", even_numbers);
}

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

// Error handling that aligns with Rust's philosophy
fn read_file_contents(path: impl AsRef<Path>) -> io::Result<String> {
    // ? operator for concise error propagation
    let mut file = File::open(path)?;
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn main() {
    // Explicit error handling
    match read_file_contents("config.txt") {
        Ok(contents) => println!("File contents: {}", contents),
        Err(error) => eprintln!("Error reading file: {}", error),
    }
    
    // Using combinators for functional-style error handling
    let result = read_file_contents("config.txt")
        .map(|contents| contents.len())
        .map_err(|error| format!("Failed to read file: {}", error));
    
    match result {
        Ok(len) => println!("File length: {} bytes", len),
        Err(error) => eprintln!("{}", error),
    }
}

use std::fs::File;
use std::io::{self, BufReader, BufRead};

// RAII pattern for resource management
struct LinesIterator {
    reader: BufReader<File>,
}

impl LinesIterator {
    fn new(path: &str) -> io::Result<Self> {
        let file = File::open(path)?;
        let reader = BufReader::new(file);
        Ok(LinesIterator { reader })
    }
    
    fn next_line(&mut self) -> io::Result<Option<String>> {
        let mut line = String::new();
        match self.reader.read_line(&mut line) {
            Ok(0) => Ok(None), // End of file
            Ok(_) => {
                // Remove trailing newline
                if line.ends_with('\n') {
                    line.pop();
                    if line.ends_with('\r') {
                        line.pop();
                    }
                }
                Ok(Some(line))
            }
            Err(e) => Err(e),
        }
    }
}

// File is automatically closed when LinesIterator is dropped
fn main() -> io::Result<()> {
    let mut iterator = LinesIterator::new("data.txt")?;
    
    while let Ok(Some(line)) = iterator.next_line() {
        println!("Line: {}", line);
    }
    
    Ok(())
}

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

// Thread-safe counter using Rust's ownership and type system
fn main() {
    // Arc provides thread-safe reference counting
    // Mutex provides mutual exclusion
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        // Clone the Arc to share ownership across threads
        let counter = Arc::clone(&counter);
        
        // Spawn a thread
        let handle = thread::spawn(move || {
            // Lock the mutex to access the data
            let mut num = counter.lock().unwrap();
            *num += 1;
            // Mutex is automatically unlocked when num goes out of scope
        });
        
        handles.push(handle);
    }
    
    // Wait for all threads to complete
    for handle in handles {
        handle.join().unwrap();
    }
    
    // Access the final value
    println!("Final count: {}", *counter.lock().unwrap());
}

// Avoid fighting the borrow checker
fn process_data(data: &mut Vec<i32>) {
    // Good: Work with references when possible
    for item in data.iter_mut() {
        *item *= 2;
    }
    
    // Bad: Cloning unnecessarily
    // let mut cloned = data.clone();
    // for item in &mut cloned {
    //     *item *= 2;
    // }
    // *data = cloned;
}

// Use ownership for clarity
fn take_ownership(s: String) {
    println!("Taken: {}", s);
    // String is dropped here
}

fn borrow_only(s: &String) {
    println!("Borrowed: {}", s);
    // Original string is not affected
}

fn main() {
    let s = String::from("hello");
    
    borrow_only(&s);    // s can still be used
    take_ownership(s);  // s cannot be used after this
}

// Use traits for composable behavior
trait Logger {
    fn log(&self, message: &str);
}

struct ConsoleLogger;

impl Logger for ConsoleLogger {
    fn log(&self, message: &str) {
        println!("[LOG] {}", message);
    }
}

struct FileLogger {
    path: String,
}

impl Logger for FileLogger {
    fn log(&self, message: &str) {
        println!("[FILE:{}] {}", self.path, message);
        // In a real implementation, write to file
    }
}

// Composition over inheritance
struct Application<L: Logger> {
    logger: L,
}

impl<L: Logger> Application<L> {
    fn new(logger: L) -> Self {
        Application { logger }
    }
    
    fn run(&self) {
        self.logger.log("Application starting");
        // Application logic
        self.logger.log("Application stopping");
    }
}

fn main() {
    // Use with console logger
    let app1 = Application::new(ConsoleLogger);
    app1.run();
    
    // Use with file logger
    let app2 = Application::new(FileLogger { path: "app.log".to_string() });
    app2.run();
}

// Use the type system to prevent invalid states
enum ConnectionState {
    Disconnected,
    Connecting,
    Connected(Connection),
    Failed(Error),
}

struct Connection {
    // Connection details
}

struct Error {
    // Error details
}

struct Client {
    state: ConnectionState,
}

impl Client {
    fn new() -> Self {
        Client { state: ConnectionState::Disconnected }
    }
    
    fn connect(&mut self) {
        self.state = match self.state {
            ConnectionState::Disconnected => {
                // Attempt to connect
                ConnectionState::Connecting
            }
            _ => return, // Already connecting, connected, or failed
        };
        
        // Simulate connection attempt
        let success = true;
        
        self.state = if success {
            ConnectionState::Connected(Connection {})
        } else {
            ConnectionState::Failed(Error {})
        };
    }
    
    fn send_data(&self, data: &[u8]) -> Result<(), &'static str> {
        match &self.state {
            ConnectionState::Connected(_) => {
                // Send data
                println!("Sending {} bytes", data.len());
                Ok(())
            }
            _ => Err("Not connected"),
        }
    }
}

fn main() {
    let mut client = Client::new();
    
    // Cannot send data before connecting
    assert!(client.send_data(&[1, 2, 3]).is_err());
    
    client.connect();
    
    // Now we can send data
    if let Ok(()) = client.send_data(&[1, 2, 3]) {
        println!("Data sent successfully");
    }
}