Rust cheat sheet

use std::collections::HashMap;
 
fn main() {
    let text = "the cat sat on the mat and the cat slept";
 
    let mut counts: HashMap<&str, usize> = HashMap::new();
    for word in text.split_whitespace() {
        *counts.entry(word).or_insert(0) += 1;
    }
 
    let mut words: Vec<(&str, usize)> = counts.into_iter().collect();
    words.sort_by(|a, b| {
        b.1.cmp(&a.1) // most frequent first
            .then_with(|| a.0.cmp(b.0)) // then A to Z
    });
 
    for (word, count) in words.iter().take(3) {
        println!("{word:<5} {count}");
    }
    // the   3
    // cat   2
    // and   1
}

use std::str::FromStr;
 
#[derive(Debug, PartialEq)]
enum Command {
    Push(i64),
    Pop,
    Add,
    Print,
}
 
impl FromStr for Command {
    type Err = String;
 
    fn from_str(s: &str) -> Result<Self, Self::Err> {
        let parts: Vec<&str> = s.split_whitespace().collect();
        match parts.as_slice() {
            ["push", n] => n
                .parse()
                .map(Command::Push)
                .map_err(|e| format!("push {n}: {e}")),
            ["pop"] => Ok(Command::Pop),
            ["add"] => Ok(Command::Add),
            ["print"] => Ok(Command::Print),
            [] => Err("empty line".to_string()),
            [other, ..] => Err(format!("unknown command: {other}")),
        }
    }
}
 
fn run(program: &str) -> Result<Vec<i64>, String> {
    let mut stack = Vec::new();
    for line in program.lines() {
        match line.parse::<Command>()? {
            Command::Push(n) => stack.push(n),
            Command::Pop => {
                stack.pop().ok_or("pop on an empty stack")?;
            }
            Command::Add => {
                let (Some(b), Some(a)) = (stack.pop(), stack.pop()) else {
                    return Err("add needs two numbers".to_string());
                };
                stack.push(a + b);
            }
            Command::Print => println!("{stack:?}"),
        }
    }
    Ok(stack)
}
 
fn main() {
    println!("{:?}", run("push 2\npush 40\nadd\nprint"));
    println!("{:?}", run("push 1\nadd"));
    println!("{:?}", run("push two"));
    println!("{:?}", run("jump 3"));
    // [42]
    // Ok([42])
    // Err("add needs two numbers")
    // Err("push two: invalid digit found in string")
    // Err("unknown command: jump")
}

use std::error::Error;
use std::fmt;
use std::fs;
use std::io;
use std::num::ParseIntError;
 
#[derive(Debug)]
enum ConfigError {
    Io(io::Error),
    BadPort { line: usize, source: ParseIntError },
}
 
impl fmt::Display for ConfigError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        match self {
            ConfigError::Io(e) => write!(f, "could not read config: {e}"),
            ConfigError::BadPort { line, .. } => write!(f, "line {line}: port is not a number"),
        }
    }
}
 
impl Error for ConfigError {
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        match self {
            ConfigError::Io(e) => Some(e),
            ConfigError::BadPort { source, .. } => Some(source),
        }
    }
}
 
// Lets ? turn an io::Error into a ConfigError on its own.
impl From<io::Error> for ConfigError {
    fn from(e: io::Error) -> Self {
        ConfigError::Io(e)
    }
}
 
fn load_port(path: &str) -> Result<u16, ConfigError> {
    let text = fs::read_to_string(path)?;
    for (i, line) in text.lines().enumerate() {
        let Some((key, value)) = line.split_once('=') else {
            continue;
        };
        if key.trim() == "port" {
            return value.trim().parse().map_err(|source| ConfigError::BadPort {
                line: i + 1,
                source,
            });
        }
    }
    Ok(80)
}
 
fn main() -> Result<(), Box<dyn Error>> {
    fs::write("bad.conf", "host = localhost\nport = eighty\n")?;
 
    for path in ["missing.conf", "bad.conf"] {
        match load_port(path) {
            Ok(port) => println!("port {port}"),
            Err(ConfigError::Io(e)) if e.kind() == io::ErrorKind::NotFound => {
                println!("{path}: no file, using the defaults");
            }
            Err(e) => {
                println!("{path}: {e}");
                if let Some(cause) = e.source() {
                    println!("  caused by: {cause}");
                }
            }
        }
    }
 
    fs::remove_file("bad.conf")?;
    Ok(())
    // missing.conf: no file, using the defaults
    // bad.conf: line 2: port is not a number
    //   caused by: invalid digit found in string
}

use std::f64::consts::PI;
use std::fmt;
 
trait Shape {
    fn area(&self) -> f64;
 
    // A default method: every Shape gets it for free.
    fn describe(&self) -> String {
        format!("area {:.2}", self.area())
    }
}
 
struct Circle {
    r: f64,
}
 
struct Rect {
    w: f64,
    h: f64,
}
 
impl Shape for Circle {
    fn area(&self) -> f64 {
        PI * self.r * self.r
    }
}
 
impl Shape for Rect {
    fn area(&self) -> f64 {
        self.w * self.h
    }
    fn describe(&self) -> String {
        format!("{}x{} rectangle", self.w, self.h)
    }
}
 
impl fmt::Display for Circle {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "circle of radius {}", self.r)
    }
}
 
// Generic: one copy compiled per type, no runtime cost.
fn largest<T: PartialOrd + Copy>(items: &[T]) -> Option<T> {
    let mut iter = items.iter().copied();
    let first = iter.next()?;
    Some(iter.fold(first, |max, x| if x > max { x } else { max }))
}
 
// Trait object: different types in one Vec, method chosen at run time.
fn total_area(shapes: &[Box<dyn Shape>]) -> f64 {
    shapes.iter().map(|s| s.area()).sum()
}
 
fn main() {
    let shapes: Vec<Box<dyn Shape>> = vec![
        Box::new(Circle { r: 1.0 }),
        Box::new(Rect { w: 3.0, h: 4.0 }),
    ];
    for s in &shapes {
        println!("{:<16} {:6.2}", s.describe(), s.area());
    }
    println!("{:<16} {:6.2}", "total", total_area(&shapes));
 
    println!("{}", Circle { r: 2.0 });
    println!("{:?}", largest(&[3, 9, 4]));
    println!("{:?}", largest(&[0.5, 0.25]));
    println!("{:?}", largest::<char>(&[]));
    // area 3.14          3.14
    // 3x4 rectangle     12.00
    // total             15.14
    // circle of radius 2
    // Some(9)
    // Some(0.5)
    // None
}

// A tokenizer that hands out slices of the input instead of copying it.
// The 'a says: every token borrows from the same text the Tokens was made from.
struct Tokens<'a> {
    rest: &'a str,
}
 
impl<'a> Tokens<'a> {
    fn new(text: &'a str) -> Self {
        Tokens { rest: text }
    }
}
 
impl<'a> Iterator for Tokens<'a> {
    type Item = &'a str;
 
    fn next(&mut self) -> Option<&'a str> {
        self.rest = self.rest.trim_start();
        let first = self.rest.chars().next()?;
        let len = if first.is_ascii_digit() {
            self.rest
                .find(|c: char| !c.is_ascii_digit())
                .unwrap_or(self.rest.len())
        } else {
            first.len_utf8()
        };
        let (token, rest) = self.rest.split_at(len);
        self.rest = rest;
        Some(token)
    }
}
 
fn longest<'a>(a: &'a str, b: &'a str) -> &'a str {
    if a.len() >= b.len() { a } else { b }
}
 
fn main() {
    let source = String::from("12 + (345 * 6)");
    let tokens: Vec<&str> = Tokens::new(&source).collect();
    println!("{tokens:?}");
 
    let widest = tokens.iter().fold("", |best, t| longest(best, t));
    println!("longest token: {widest}");
 
    // drop(source); // error[E0505]: cannot move out of `source` because it is borrowed
    println!("{} tokens", tokens.len());
    // ["12", "+", "(", "345", "*", "6", ")"]
    // longest token: 345
    // 7 tokens
}

use std::sync::mpsc;
use std::thread;
 
fn is_prime(n: u64) -> bool {
    n >= 2 && (2..).take_while(|d| d * d <= n).all(|d| n % d != 0)
}
 
fn main() {
    let numbers: Vec<u64> = (1..=100).collect();
    let (tx, rx) = mpsc::channel();
 
    // Scoped threads may borrow `numbers`: they all finish before scope returns.
    thread::scope(|s| {
        for (i, chunk) in numbers.chunks(25).enumerate() {
            let tx = tx.clone();
            s.spawn(move || {
                let count = chunk.iter().filter(|&&n| is_prime(n)).count();
                tx.send((i, count)).unwrap();
            });
        }
    });
    drop(tx); // the last sender: lets the loop below end
 
    let mut results: Vec<(usize, usize)> = rx.iter().collect();
    results.sort(); // threads finish in any order
    for (i, count) in &results {
        println!("chunk {i}: {count} primes");
    }
    let total: usize = results.iter().map(|(_, c)| c).sum();
    println!("total: {total}");
    // chunk 0: 9 primes
    // chunk 1: 6 primes
    // chunk 2: 6 primes
    // chunk 3: 4 primes
    // total: 25
}