// Rust - Systems programming language

/*
Rust is a multi-paradigm, general-purpose programming language that 
emphasizes performance, type safety, and concurrency. Developed by 
Mozilla Research, Rust was first released in 2010. It provides memory 
safety without garbage collection by using a borrow checker to validate 
references.

Key Features:
- Memory safety without garbage collection
- Zero-cost abstractions
- Concurrency support
- Functional programming features
- Rich type system
- Pattern matching
- Cross-platform
*/

// Struct definition
struct Animal {
    name: String,
}

// Implementation block for Animal
impl Animal {
    fn new(name: &str) -> Animal {
        Animal {
            name: name.to_string(),
        }
    }
    
    fn speak(&self) {
        println!("{} makes a sound", self.name);
    }
}

// Function with parameters
fn add(a: i32, b: i32) -> i32 {
    a + b
}

// Generic function
fn largest<T: PartialOrd + Copy>(list: &[T]) -> T {
    let mut largest = list[0];
    
    for &item in list {
        if item > largest {
            largest = item;
        }
    }
    
    largest
}

fn main() {
    // Variables and data types
    let language = "Rust";
    let version = 1.70;
    let is_safe = true;
    
    println!("Welcome to {}!", language);
    
    // Control structures
    if is_safe {
        println!("{} emphasizes memory safety", language);
    }
    
    // Arrays
    let features = ["Safe", "Fast", "Concurrent", "Zero-cost abstractions"];
    
    println!("Key Features:");
    for (i, feature) in features.iter().enumerate() {
        println!("{}. {}", i+1, feature);
    }
    
    // Vectors (dynamic arrays)
    let mut numbers = vec![1, 2, 3, 4, 5];
    numbers.push(6);
    
    println!("Numbers: {:?}", numbers);
    
    // HashMap
    use std::collections::HashMap;
    
    let mut language_creators = HashMap::new();
    language_creators.insert("Rust", "Mozilla Research");
    language_creators.insert("C", "Dennis Ritchie");
    language_creators.insert("Java", "Sun Microsystems");
    
    println!("Language Creators:");
    for (lang, creator) in &language_creators {
        println!("{}: {}", lang, creator);
    }
    
    // Struct usage
    let dog = Animal::new("Buddy");
    dog.speak();
    
    // Function calls
    let result = add(5, 3);
    println!("5 + 3 = {}", result);
    
    // Generic function
    let number_list = vec![34, 50, 25, 100, 65];
    let result = largest(&number_list);
    println!("The largest number is {}", result);
    
    // Error handling with Result
    fn divide(a: f64, b: f64) -> Result<f64, String> {
        if b == 0.0 {
            Err("Cannot divide by zero".to_string())
        } else {
            Ok(a / b)
        }
    }
    
    match divide(10.0, 2.0) {
        Ok(result) => println!("10 / 2 = {}", result),
        Err(e) => println!("Error: {}", e),
    }
    
    // Match expression (pattern matching)
    let number = 5;
    
    match number {
        1 => println!("One"),
        2 => println!("Two"),
        3 => println!("Three"),
        _ => println!("Other number"),
    }
    
    println!("Rust demo completed!");
}