Rust Quick Reference

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

let x = 5;          // immutable

let mut count = 0;  // mutable

const MAX: u32 = 100;

let n: i32 = -5;

let f: f64 = 3.5;

let ok: bool = true;

println!("{name} is {age}");

println!("{:?}", value);  // debug

format!("{:.2}", price)

let n: i32 = "42".parse().unwrap();

n.to_string()

x as f64

let a = String::from("hi");
let b = a;  // a can no longer be used

let b = a.clone();

fn len(s: &str) -> usize { s.len() }
len(&name);

fn push(v: &mut Vec<i32>) { v.push(1); }
push(&mut nums);

fn longest<'a>(a: &'a str, b: &'a str) -> &'a str { }

let s = String::from("Ada");

let slice: &str = &s[0..2];

s.push_str(" Lovelace");

let full = format!("{a} {b}");

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

v.push(4);

v.sort();

for n in &v { }

for (i, n) in v.iter().enumerate() { }

let doubled: Vec<i32> = v.iter().filter(|n| **n > 1).map(|n| n * 2).collect();

let total: i32 = v.iter().sum();

v.reverse();

v.iter().rev()

use std::collections::HashMap;
let mut ages = HashMap::new();
ages.insert("Ada", 36);
ages.get("Ada");

*counts.entry(word).or_insert(0) += 1;

#[derive(Debug, Clone)]
struct User {
    name: String,
    age: u32,
}

impl User {
    fn new(name: &str) -> Self {
        Self { name: name.into(), age: 0 }
    }
    fn greet(&self) -> String {
        format!("Hi {}", self.name)
    }
}

enum Shape {
    Circle(f64),
    Rect { w: f64, h: f64 },
}

match shape {
    Shape::Circle(r) => 3.14 * r * r,
    Shape::Rect { w, h } => w * h,
}

if let Some(user) = find(id) {
    println!("{}", user.name);
}

trait Area {
    fn area(&self) -> f64;
}
impl Area for Shape { fn area(&self) -> f64 { 0.0 } }

let x: Option<i32> = Some(5);

x.unwrap_or(0)

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

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

match parse("42") {
    Ok(n) => println!("{n}"),
    Err(e) => eprintln!("{e}"),
}

panic!("unrecoverable");

value.expect("value should exist")

cargo new my_app

cargo run

cargo build --release

cargo test

cargo add serde --features derive

cargo check

cargo clippy

cargo fmt