Rust

Memory safety without garbage collection. Fast and fearless.

⚠ pattern-based checks (code is analyzed, not compiled)

About Rust

Rust is a systems language focused on safety and performance. Its ownership model catches memory bugs at compile time — no GC, no segfaults. Used in Firefox, Discord, Cloudflare, and the Linux kernel. NOTE: Code is checked by pattern matching, not compiled. Focus on idiomatic Rust.

Quick-reference cheat sheet

// Rust cheat-sheet

fn main() {
    let x = 42;             // immutable by default
    let mut y = 10;         // mut to make mutable
    y += 1;

    let name: &str = "ada"; // string slice
    let owned: String = String::from("ada");

    println!("Hello, {}!", name);
    println!("x = {}, y = {}", x, y);

    // Conditions are expressions
    let kind = if x > 0 { "positive" } else { "non-positive" };

    // Loops
    for i in 0..5 { println!("{}", i); }

    let nums = vec![1, 2, 3, 4];
    let sum: i32 = nums.iter().sum();

    // Option / Result
    let maybe: Option<i32> = Some(5);
    match maybe {
        Some(n) => println!("got {}", n),
        None => println!("nothing"),
    }
}

fn add(a: i32, b: i32) -> i32 {
    a + b           // no semicolon = return
}

struct Point { x: i32, y: i32 }
impl Point {
    fn new(x: i32, y: i32) -> Self { Point { x, y } }
}

// Traits
trait Greet { fn hello(&self) -> String; }

// Closures
let add1 = |x: i32| x + 1;

// Error handling with Result
fn parse_int(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse::<i32>()
}

About Rust

Tasks