Learning Rust Programming

Rust variables are immutable by default - you must explicitly use mut to make them mutable.

fn main() {
    let x = 5;        // Immutable by default
    // x = 6;         // ERROR: cannot assign twice
    
    let mut y = 10;   // Explicitly mutable
    y = 15;           // OK
    
    // Type annotations (usually inferred)
    let z: i32 = 42;
    let pi: f64 = 3.14159;
    let name: &str = "Alice";
    
    // Shadowing (different from mutation)
    let spaces = "   ";
    let spaces = spaces.len(); // New variable, different type
}

Rust's ownership system is its most unique feature. Every value has a single owner, and borrowing follows strict rules.

fn main() {
    let s1 = String::from("hello");
    let s2 = s1;  // s1 is MOVED to s2, s1 is invalid
    // println!("{}", s1); // ERROR: value borrowed after move
    
    let s3 = String::from("world");
    let len = calculate_length(&s3); // Borrow with &
    println!("{} has length {}", s3, len); // s3 still valid
    
    let mut s4 = String::from("hello");
    change(&mut s4); // Mutable borrow
    println!("{}", s4);
}

fn calculate_length(s: &String) -> usize {
    s.len() // Returns length without taking ownership
}

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

Structs group related data together. Methods are defined in impl blocks.

struct User {
    username: String,
    email: String,
    active: bool,
}

impl User {
    fn new(username: String, email: String) -> User {
        User {
            username,
            email,
            active: true,
        }
    }
    
    fn deactivate(&mut self) {
        self.active = false;
    }
    
    fn is_admin(&self) -> bool {
        self.username == "admin"
    }
}

Enums are incredibly powerful in Rust. Pattern matching with match is exhaustive and safe.

enum Message {
    Quit,
    Move { x: i32, y: i32 },
    Write(String),
    ChangeColor(i32, i32, i32),
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Quit"),
        Message::Move { x, y } => println!("Move to ({}, {})", x, y),
        Message::Write(text) => println!("Write: {}", text),
        Message::ChangeColor(r, g, b) => println!("Color: ({}, {}, {})", r, g, b),
    }
}

Rust doesn't have exceptions. Instead, use Result for errors and Option for nullable values.

use std::fs::File;
use std::io::Read;

fn read_file(path: &str) -> Result {
    let mut file = File::open(path)?;  // ? propagates errors
    let mut contents = String::new();
    file.read_to_string(&mut contents)?;
    Ok(contents)
}

fn divide(a: f64, b: f64) -> Option {
    if b == 0.0 {
        None
    } else {
        Some(a / b)
    }
}

Traits define shared behavior. Generics let you write flexible, reusable code.

trait Summary {
    fn summarize(&self) -> String;
}

struct Article {
    title: String,
    content: String,
}

impl Summary for Article {
    fn summarize(&self) -> String {
        format!("{}: {}", self.title, &self.content[0..50])
    }
}

fn notify(item: &T) {
    println!("Breaking news! {}", item.summarize());
}

Rust's async/await syntax enables efficient concurrent programming. Tokio is the most popular async runtime.

use tokio;

#[tokio::main]
async fn main() {
    let result = fetch_data().await;
    println!("Result: {}", result);
}

async fn fetch_data() -> String {
    // Async operations don't block the thread
    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    "Data fetched!".to_string()
}