Rust

let s = String::from("hello");
let t = s;                  // move: s is no longer usable
let u = t.clone();          // explicit copy when you really need two owners

fn read(v: &[u8]) {}        // borrow: caller keeps ownership
fn consume(v: Vec<u8>) {}   // take ownership: caller cannot use it afterwards

use thiserror::Error;

#[derive(Debug, Error)]
pub enum StoreError {
    #[error("user {0} not found")]
    NotFound(i64),
    #[error("database: {0}")]
    Db(#[from] sqlx::Error),      // From impl, so ? converts automatically
}

pub fn get(id: i64) -> Result<User, StoreError> {
    let row = query(id)?;          // sqlx::Error converts via #[from]
    row.ok_or(StoreError::NotFound(id))
}

use anyhow::{Context, Result};

fn main() -> Result<()> {
    let cfg = std::fs::read_to_string("config.toml")
        .context("reading config.toml")?;     // adds context, keeps the source
    Ok(())
}

let name: Option<&str> = map.get("name").map(String::as_str);

let total: u64 = items.iter().filter(|i| i.active).map(|i| i.bytes).sum();
let first_err = results.iter().find_map(|r| r.as_ref().err());
let parsed: Result<Vec<i32>, _> = inputs.iter().map(|s| s.parse::<i32>()).collect();  // short-circuits
let (ok, bad): (Vec<_>, Vec<_>) = results.into_iter().partition(Result::is_ok);

value.unwrap_or_default();
value.unwrap_or_else(|| expensive());
value.ok_or(Error::Missing)?;

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Config {
    pub name: String,
    #[serde(default = "default_port")]
    pub port: u16,
}

pub trait Store {
    fn get(&self, id: i64) -> Result<User, StoreError>;
}

fn handler<S: Store>(store: &S) {}          // static dispatch, monomorphised
fn handler_dyn(store: &dyn Store) {}        // dynamic dispatch, one copy of the code

let state = Arc::new(Mutex::new(HashMap::new()));
let s = Arc::clone(&state);
std::thread::spawn(move || {
    s.lock().unwrap().insert("k", 1);      // lock poisoned only if a holder panicked
});

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let client = reqwest::Client::builder().timeout(Duration::from_secs(10)).build()?;

    let (a, b) = tokio::try_join!(fetch(&client, "/a"), fetch(&client, "/b"))?;

    let results = futures::future::join_all(ids.iter().map(|id| fetch_one(&client, *id))).await;

    tokio::select! {
        res = work() => res?,
        _ = tokio::time::sleep(Duration::from_secs(5)) => anyhow::bail!("timeout"),
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_valid_input() {
        assert_eq!(parse("a=1").unwrap(), Config { name: "a".into(), port: 1 });
    }

    #[test]
    fn rejects_empty() {
        assert!(matches!(parse(""), Err(ParseError::Empty)));
    }

    #[tokio::test]
    async fn fetches() { /* ... */ }
}

[profile.release]
lto = "thin"
codegen-units = 1
panic = "abort"      # smaller and faster, but no unwinding and no catch_unwind
strip = "symbols"

cargo build --release --target x86_64-unknown-linux-musl   # static binary for a scratch image
cargo test --workspace --all-features
cargo clippy --all-targets --all-features -- -D warnings
cargo tree -i openssl                                      # who pulls this in
cargo update -p serde --precise 1.0.203

# Explain the error you just got
rustc --explain E0502

# Fastest feedback loop
cargo watch -x check -x test

# Show where time goes in a slow build
cargo build --release --timings && open target/cargo-timings/cargo-timing.html

# Duplicate dependency versions bloating the build
cargo tree -d

# Unused dependencies
cargo +nightly udeps

# Which features are enabled for a crate
cargo tree -e features -i tokio

# Expand a derive or macro to see what it generates
cargo expand --lib path::to::module

# Static musl binary, no glibc
cargo build --release --target x86_64-unknown-linux-musl && ldd target/x86_64-unknown-linux-musl/release/app

# Check the whole workspace without building artefacts
cargo check --workspace --all-targets --all-features

# Fail CI on formatting
cargo fmt --all -- --check

# Security advisories in the lock file
cargo audit --deny warnings

# Miri for undefined behaviour in unsafe code
cargo +nightly miri test