Rust

fn main() {
    println!("Hello, World! 🦀");

    // Variables are immutable by default
    let name = "Rust";
    let year: u32 = 2015;

    println!("{name} was first released in {year}.");
    println!("It has been {} years since release.", 2026 - year);
}

fn main() {
    // ── Ownership ─────────────────────────────────────────────
    let s1 = String::from("hello");
    let s2 = s1;          // s1 is MOVED into s2
    // println!("{s1}");  // ← compile error: value used after move

    // ── Cloning (deep copy) ───────────────────────────────────
    let s3 = String::from("world");
    let s4 = s3.clone();  // explicit deep copy
    println!("s3={s3}, s4={s4}");   // both valid

    // ── Borrowing (references) ────────────────────────────────
    let s5 = String::from("Rust");
    let len = calculate_length(&s5); // borrow, not move
    println!("Length of '{s5}' is {len}");  // s5 still valid

    // ── Mutable reference ─────────────────────────────────────
    let mut s6 = String::from("hello");
    change(&mut s6);
    println!("{s6}");  // "hello, world"
}

fn calculate_length(s: &String) -> usize {
    s.len()   // s is a reference — does not take ownership
}   // s goes out of scope but doesn't drop the value

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

fn main() {
    // ── Scalar types ──────────────────────────────────────────
    let i:   i32   = -42;        // signed 32-bit integer
    let u:   u64   = 1_000_000;  // unsigned 64-bit (underscores ok)
    let f:   f64   = 3.14159;    // 64-bit float
    let b:   bool  = true;
    let c:   char  = '🦀';       // Unicode scalar value

    // ── Compound types ────────────────────────────────────────
    let tup: (i32, f64, char) = (500, 6.4, 'z');
    let (x, y, z) = tup;         // destructuring
    println!("Tuple: {x}, {y}, {z}");

    let arr: [i32; 5] = [1, 2, 3, 4, 5];
    println!("Array[2] = {}", arr[2]);

    // ── String types ──────────────────────────────────────────
    let s_lit:  &str   = "string slice — borrowed, immutable";
    let s_own:  String = String::from("owned String — heap allocated");
    let s_fmt:  String = format!("{} and {}", s_lit, s_own);
    println!("{s_fmt}");

    // ── Collections ───────────────────────────────────────────
    let mut v: Vec<i32> = vec![1, 2, 3];
    v.push(4);
    v.push(5);
    println!("Vec: {:?}", v);

    use std::collections::HashMap;
    let mut map = HashMap::new();
    map.insert("Rust",       2015);
    map.insert("Go",         2009);
    map.insert("TypeScript", 2012);
    for (lang, year) in &map {
        println!("{lang}: {year}");
    }
}

fn main() {
    // ── if / else if / else ───────────────────────────────────
    let score = 87;
    let grade = if score >= 90 { "A" }
                else if score >= 80 { "B" }
                else if score >= 70 { "C" }
                else { "F" };
    println!("Score {score} → Grade {grade}");

    // ── loop (infinite, with break value) ─────────────────────
    let mut counter = 0;
    let result = loop {
        counter += 1;
        if counter == 5 { break counter * 10; }
    };
    println!("Loop result: {result}");  // 50

    // ── while ─────────────────────────────────────────────────
    let mut n = 3;
    while n > 0 { print!("{n}… "); n -= 1; }
    println!("Go! 🚀");

    // ── for over a range ──────────────────────────────────────
    let sum: i32 = (1..=100).sum();
    println!("Sum 1–100 = {sum}");  // 5050

    // ── for over a collection ─────────────────────────────────
    let langs = ["Rust", "Go", "C++", "Zig"];
    for (i, lang) in langs.iter().enumerate() {
        println!("{}: {lang}", i + 1);
    }

    // ── match (Rust's powerful pattern matching) ──────────────
    let num = 7;
    match num {
        1       => println!("one"),
        2 | 3   => println!("two or three"),
        4..=6   => println!("four to six"),
        n if n % 2 == 0 => println!("{n} is even"),
        _       => println!("{num} is something else"),
    }
}

// ── Structs ───────────────────────────────────────────────────
#[derive(Debug, Clone)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    // Associated function (constructor)
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }

    // Method — takes &self
    fn distance_from_origin(&self) -> f64 {
        (self.x * self.x + self.y * self.y).sqrt()
    }

    fn translate(&mut self, dx: f64, dy: f64) {
        self.x += dx;
        self.y += dy;
    }
}

// ── Enums ─────────────────────────────────────────────────────
#[derive(Debug)]
enum Shape {
    Circle { radius: f64 },
    Rectangle { width: f64, height: f64 },
    Triangle { base: f64, height: f64 },
}

impl Shape {
    fn area(&self) -> f64 {
        match self {
            Shape::Circle    { radius }        => std::f64::consts::PI * radius * radius,
            Shape::Rectangle { width, height } => width * height,
            Shape::Triangle  { base, height }  => 0.5 * base * height,
        }
    }
}

fn main() {
    let mut p = Point::new(3.0, 4.0);
    println!("Point: {:?}", p);
    println!("Distance: {:.2}", p.distance_from_origin()); // 5.00
    p.translate(1.0, 1.0);
    println!("After translate: {:?}", p);

    let shapes: Vec<Shape> = vec![
        Shape::Circle    { radius: 5.0 },
        Shape::Rectangle { width: 4.0, height: 6.0 },
        Shape::Triangle  { base: 3.0, height: 8.0 },
    ];

    for shape in &shapes {
        println!("{:?} → area = {:.2}", shape, shape.area());
    }
}

use std::num::ParseIntError;
use std::fmt;

// ── Custom error type ─────────────────────────────────────────
#[derive(Debug)]
enum AppError {
    ParseError(ParseIntError),
    NegativeNumber(i32),
    TooBig(i32),
}

impl fmt::Display for AppError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            AppError::ParseError(e)     => write!(f, "Parse error: {e}"),
            AppError::NegativeNumber(n) => write!(f, "Negative number: {n}"),
            AppError::TooBig(n)         => write!(f, "Number too big: {n} (max 100)"),
        }
    }
}

impl From<ParseIntError> for AppError {
    fn from(e: ParseIntError) -> Self {
        AppError::ParseError(e)
    }
}

fn parse_positive(s: &str) -> Result<i32, AppError> {
    let n: i32 = s.parse()?;  // ? auto-converts ParseIntError via From
    if n < 0  { return Err(AppError::NegativeNumber(n)); }
    if n > 100 { return Err(AppError::TooBig(n)); }
    Ok(n)
}

fn main() {
    let inputs = ["42", "-5", "200", "abc", "99"];

    for input in inputs {
        match parse_positive(input) {
            Ok(n)  => println!("✓ '{input}' → {n}"),
            Err(e) => println!("✗ '{input}' → {e}"),
        }
    }

    // Option<T> — value that may or may not exist
    let numbers = vec![1, 2, 3, 4, 5];
    match numbers.iter().find(|&&x| x > 3) {
        Some(n) => println!("First > 3: {n}"),
        None    => println!("None found"),
    }
}