Rust Cheat Sheet

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

// Single line comment
/* Multi-line
   comment */
/// Doc comment

println!("{}", value);       // Display
println!("{:?}", value);     // Debug
println!("{:#?}", value);    // Pretty debug

let mut input = String::new();
std::io::stdin().read_line(&mut input)?;

cargo new project   // Create
cargo build         // Compile
cargo run           // Build & run

let name = "John";

let mut count = 0;

const MAX: u32 = 100;

let age: i32 = 25;

let tuple: (i32, f64, &str) = (1, 2.0, "hello");

let arr: [i32; 5] = [1, 2, 3, 4, 5];

let mut vec = vec![1, 2, 3];

let mut map = HashMap::new();

+ - * /    // Add, Sub, Mul, Div
%          // Modulus (remainder)
// No ++ or -- in Rust

==  !=     // Equal, Not equal
>   <      // Greater, Less than
>=  <=     // Greater/Less or equal

&&   // Short-circuit AND
||   // Short-circuit OR
!    // NOT

=   +=  -=  *=  /=  %=
&=  |=  ^=  <<= >>=

&   // AND
|   // OR
^   // XOR
!   // NOT (for bool)
<<  // Left shift
>>  // Right shift

&x      // Immutable reference
&mut x  // Mutable reference
*ptr    // Dereference

?    // Propagate error
result?  // Return Err if error

loop {
    if done { break; }
}

let result = loop {
    if found {
        break value;
    }
};

while count < 10 {
    count += 1;
}

while let Some(x) = stack.pop() {
    println!("{}", x);
}

for i in 0..5 {
    println!("{}", i);  // 0, 1, 2, 3, 4
}

for i in 0..=5 {
    println!("{}", i);  // 0, 1, 2, 3, 4, 5
}

for item in vec.iter() {
    println!("{}", item);
}

for (i, item) in vec.iter().enumerate() {
    println!("{}: {}", i, item);
}

for i in 0..10 {
    if i == 5 { continue; }
    if i == 8 { break; }
}

'outer: for i in 0..3 {
    for j in 0..3 {
        if j == 1 { break 'outer; }
    }
}

if x > 0 {
    println!("positive");
} else if x < 0 {
    println!("negative");
} else {
    println!("zero");
}

let result = if condition { 5 } else { 10 };

if let Some(x) = option {
    println!("{}", x);
}

match value {
    1 => println!("one"),
    2 | 3 => println!("two or three"),
    4..=10 => println!("4 to 10"),
    _ => println!("other"),
}

match num {
    n if n < 0 => "negative",
    0 => "zero",
    n if n > 0 => "positive",
    _ => unreachable!(),
}

fn greet(name: &str) -> String {
    format!("Hello, {}!", name)
}

fn print_msg(msg: &str) {
    println!("{}", msg);
}

let add = |a, b| a + b;

let square = |x: i32| -> i32 { x * x };

let s1 = String::from("hello");
let s2 = s1;  // s1 is moved

let s1 = String::from("hello");
let s2 = s1.clone();

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

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

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

impl Person {
    fn new(name: &str, age: u32) -> Self {
        Self { name: name.to_string(), age }
    }

    fn greet(&self) -> String {
        format!("Hi, I'm {}", self.name)
    }
}

enum Status {
    Active,
    Inactive,
    Pending(String),
}

let value: Option<i32> = Some(5);
let none: Option<i32> = None;

fn divide(a: i32, b: i32) -> Result<i32, String> {
    if b == 0 {
        Err("Division by zero".to_string())
    } else {
        Ok(a / b)
    }
}

match result {
    Ok(val) => println!("Success: {}", val),
    Err(e) => println!("Error: {}", e),
}

fn read_file() -> Result<String, io::Error> {
    let content = fs::read_to_string("file.txt")?;
    Ok(content)
}

let value = some_option.unwrap();

let value = result.expect("Failed to get value");

trait Greet {
    fn greet(&self) -> String;
}

impl Greet for Person {
    fn greet(&self) -> String {
        format!("Hello, I'm {}", self.name)
    }
}

#[derive(Debug, Clone, PartialEq)]
struct Point { x: i32, y: i32 }