Cheatsheet: Rust

let name = "Alice";
let mut count = 0;
count += 1;

let age: i32 = 30;
let price: f64 = 19.99;
let active: bool = true;
let coords: (i32, i32) = (10, 20);
let nums = [1, 2, 3];

let spaces = "  hi  ";
let spaces = spaces.trim();
let spaces = spaces.len();

let score = 88;
let grade = if score >= 90 {
    "A"
} else if score >= 80 {
    "B"
} else {
    "C"
};

let day = "sat";
match day {
    "sat" | "sun" => println!("weekend"),
    _ => println!("weekday"),
}

let mut n = 0;
loop {
    n += 1;
    if n == 2 { break; }
}

while n < 4 {
    n += 1;
}

for item in [10, 20, 30] {
    println!("{item}");
}

let a = String::from("hello");
let b = a; // ownership moves to b
// println!("{a}"); // no longer valid

fn len(text: &String) -> usize {
    text.len()
}

let name = String::from("Alice");
let size = len(&name);

fn append_world(text: &mut String) {
    text.push_str(" world");
}

let mut message = String::from("hello");
append_world(&mut message);

Use owned values when you need to store or return data.
Use &T for read-only access.
Use &mut T when one caller needs to modify a value.

struct User {
    name: String,
    age: u32,
}

let user = User {
    name: String::from("Alice"),
    age: 30,
};

impl User {
    fn greet(&self) -> String {
        format!("Hi, {}", self.name)
    }
}

enum Status {
    Ok,
    NotFound,
}

let code = match Status::Ok {
    Status::Ok => 200,
    Status::NotFound => 404,
};

trait Speak {
    fn speak(&self) -> String;
}

struct Dog;

impl Speak for Dog {
    fn speak(&self) -> String {
        "woof".to_string()
    }
}

fn say_twice<T: Speak>(item: &T) {
    println!("{} {}", item.speak(), item.speak());
}

let maybe_name = Some("Alice");
if let Some(name) = maybe_name {
    println!("{name}");
}

let port: Result<u16, _> = "8080".parse();
match port {
    Ok(value) => println!("{value}"),
    Err(err) => eprintln!("{err}"),
}

fn read_name() -> Result<String, std::io::Error> {
    let text = std::fs::read_to_string("name.txt")?;
    Ok(text.trim().to_string())
}

let mut nums = vec![1, 2, 3];
nums.push(4);
let doubled: Vec<i32> = nums.iter().map(|n| n * 2).collect();

use std::collections::HashMap;

let mut counts = HashMap::new();
counts.insert("apple", 2);
counts.entry("apple").and_modify(|n| *n += 1).or_insert(1);

for (key, value) in &counts {
    println!("{key}: {value}");
}