Rust Programming Language: Getting Started

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Restart your shell, then verify
rustc --version    # rustc 1.78.0 (or newer)
cargo --version    # cargo 1.78.0

# Create a new binary project
cargo new hello-rust
cd hello-rust

# Project structure:
# hello-rust/
# ├── Cargo.toml    ← project metadata and dependencies
# └── src/
#     └── main.rs   ← entry point

# Build and run
cargo run

fn main() {
    // Variables are immutable by default
    let name = "Rust";
    let version: u32 = 1;

    // Use `mut` to make a variable mutable
    let mut count = 0;
    count += 1;

    println!("Hello from {} {}!", name, version);
    println!("Count: {}", count);

    // Shadowing: re-bind a name to a new value
    let spaces = "   ";
    let spaces = spaces.len(); // now an integer
    println!("Spaces: {}", spaces);

    // Basic arithmetic
    let sum = 5 + 10;
    let product = 4 * 30;
    let remainder = 43 % 5;
    println!("Sum={} Product={} Remainder={}", sum, product, remainder);
}

[package]
name = "hello-rust"
version = "0.1.0"
edition = "2021"

[dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
rand = "0.8"

fn main() {
    // --- MOVE semantics ---
    let s1 = String::from("hello");
    let s2 = s1;           // s1 is *moved* into s2
    // println!("{}", s1); // ERROR: s1 is no longer valid!
    println!("{}", s2);    // OK

    // --- CLONE: explicit deep copy ---
    let s3 = s2.clone();   // expensive, but both s2 and s3 are valid
    println!("s2={} s3={}", s2, s3);

    // --- Copy types (stack-only values like integers) ---
    let x = 5;
    let y = x; // integers implement Copy, so x is still valid
    println!("x={} y={}", x, y);

    // --- BORROWING: pass a reference instead of moving ---
    let s4 = String::from("world");
    let len = calculate_length(&s4); // pass a reference
    println!("{} has {} chars", s4, len); // s4 still valid

    // --- MUTABLE borrowing ---
    let mut s5 = String::from("hello");
    change(&mut s5);
    println!("{}", s5); // "hello world"
}

fn calculate_length(s: &String) -> usize {
    s.len()  // s is a reference; no ownership is taken
}

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

// Define a struct
#[derive(Debug)]
struct Rectangle {
    width: f64,
    height: f64,
}

// Implement methods on the struct
impl Rectangle {
    // Associated function (like a static method / constructor)
    fn new(width: f64, height: f64) -> Rectangle {
        Rectangle { width, height }
    }

    // Method: takes &self (immutable reference to self)
    fn area(&self) -> f64 {
        self.width * self.height
    }

    fn perimeter(&self) -> f64 {
        2.0 * (self.width + self.height)
    }

    fn is_square(&self) -> bool {
        self.width == self.height
    }

    // Method that takes another Rectangle
    fn can_hold(&self, other: &Rectangle) -> bool {
        self.width > other.width && self.height > other.height
    }
}

fn main() {
    let rect1 = Rectangle::new(30.0, 50.0);
    let rect2 = Rectangle { width: 10.0, height: 40.0 };

    println!("rect1 = {:?}", rect1);
    println!("Area: {}", rect1.area());
    println!("Perimeter: {}", rect1.perimeter());
    println!("Is square: {}", rect1.is_square());
    println!("rect1 can hold rect2: {}", rect1.can_hold(&rect2));
}

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

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

    fn name(&self) -> &str {
        match self {
            Shape::Circle(_)      => "Circle",
            Shape::Rectangle(..)  => "Rectangle",
            Shape::Triangle { .. } => "Triangle",
        }
    }
}

fn describe_number(n: i32) -> &'static str {
    match n {
        0         => "zero",
        1..=9     => "single digit",
        10..=99   => "double digit",
        100..=999 => "triple digit",
        _         => "large number",  // _ is the catch-all
    }
}

fn main() {
    let shapes = vec![
        Shape::Circle(5.0),
        Shape::Rectangle(4.0, 6.0),
        Shape::Triangle { base: 3.0, height: 8.0 },
    ];

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

    println!("{}", describe_number(42));  // "double digit"
}

let config_max = Some(3u8);

// Verbose match:
match config_max {
    Some(max) => println!("Max is {}", max),
    _ => (),
}

// Concise if let:
if let Some(max) = config_max {
    println!("Max is {}", max);
}

// with else:
if let Some(max) = config_max {
    println!("Max is {}", max);
} else {
    println!("No max configured");
}

use std::thread;
use std::sync::{Arc, Mutex};
use std::sync::mpsc;  // multiple producer, single consumer

fn main() {
    // --- Threads with shared state via Arc<Mutex<T>> ---
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];

    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }

    for handle in handles {
        handle.join().unwrap();
    }
    println!("Counter: {}", *counter.lock().unwrap()); // 10

    // --- Message passing with channels ---
    let (tx, rx) = mpsc::channel();

    thread::spawn(move || {
        let messages = vec!["hello", "from", "thread"];
        for msg in messages {
            tx.send(msg).unwrap();
            thread::sleep(std::time::Duration::from_millis(100));
        }
    });

    for received in rx {
        println!("Got: {}", received);
    }
}

use std::fs;
use std::io::{self, BufRead, Write};

#[derive(Debug)]
struct Task {
    id: usize,
    title: String,
    done: bool,
}

impl Task {
    fn new(id: usize, title: &str) -> Self {
        Task {
            id,
            title: title.to_string(),
            done: false,
        }
    }

    fn to_line(&self) -> String {
        format!("{}|{}|{}", self.id, self.title, self.done)
    }
}

fn load_tasks(path: &str) -> Vec<Task> {
    let Ok(content) = fs::read_to_string(path) else {
        return vec![];
    };
    content
        .lines()
        .filter_map(|line| {
            let parts: Vec<&str> = line.splitn(3, '|').collect();
            if parts.len() == 3 {
                Some(Task {
                    id: parts[0].parse().ok()?,
                    title: parts[1].to_string(),
                    done: parts[2] == "true",
                })
            } else {
                None
            }
        })
        .collect()
}

fn save_tasks(path: &str, tasks: &[Task]) -> io::Result<()> {
    let mut file = fs::File::create(path)?;
    for task in tasks {
        writeln!(file, "{}", task.to_line())?;
    }
    Ok(())
}

fn main() {
    let path = "tasks.txt";
    let mut tasks = load_tasks(path);

    let args: Vec<String> = std::env::args().collect();
    match args.get(1).map(String::as_str) {
        Some("add") => {
            let title = args[2..].join(" ");
            let id = tasks.len() + 1;
            tasks.push(Task::new(id, &title));
            save_tasks(path, &tasks).unwrap();
            println!("Added task #{}: {}", id, title);
        }
        Some("done") => {
            if let Some(id) = args.get(2).and_then(|s| s.parse::<usize>().ok()) {
                if let Some(task) = tasks.iter_mut().find(|t| t.id == id) {
                    task.done = true;
                    save_tasks(path, &tasks).unwrap();
                    println!("Task #{} marked as done", id);
                } else {
                    eprintln!("Task {} not found", id);
                }
            }
        }
        Some("list") | None => {
            for task in &tasks {
                let status = if task.done { "✓" } else { "○" };
                println!("[{}] #{} {}", status, task.id, task.title);
            }
            if tasks.is_empty() {
                println!("No tasks. Add one: cargo run -- add Buy groceries");
            }
        }
        Some(cmd) => eprintln!("Unknown command: {}", cmd),
    }
}