Rust

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

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

use thiserror::Error;

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

pub fn get(id: i64) -> Result<User, StoreError> {
    let row = query(id)?;          // sqlx::Error becomes StoreError::Db 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")?;     // attaches a message, keeps the underlying 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();  // stops at the first Err
let (ok, bad): (Vec<_>, Vec<_>) = results.into_iter().partition(Result::is_ok);

value.unwrap_or_default();          // the type's default when None
value.unwrap_or_else(|| expensive());   // computed only when None
value.ok_or(Error::Missing)?;       // Option to Result, then propagate

#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
pub struct Config {
    pub name: String,
    #[serde(default = "default_port")]      // called when the field is absent from the input
    pub port: u16,
}

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

fn handler<S: Store>(store: &S) {}          // static dispatch, monomorphised per type
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);                // bump the refcount, not the data
std::thread::spawn(move || {
    s.lock().unwrap().insert("k", 1);      // lock() errors only if a previous holder panicked (poisoning)
});

#[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"))?;   // both, fail on first error

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

    tokio::select! {                          // whichever branch completes first wins
        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)));   // match the variant, ignore its fields
    }

    #[tokio::test]
    async fn fetches() { /* an async test on the Tokio runtime */ }
}

[profile.release]
lto = "thin"           # link-time optimisation across crates; "fat" is slower to build, marginally smaller
codegen-units = 1      # one unit gives the optimiser the whole crate, at the cost of parallel build time
panic = "abort"        # smaller and faster, but no stack unwinding and no catch_unwind
strip = "symbols"      # drop symbol tables from the binary

cargo build --release --target x86_64-unknown-linux-musl   # fully static binary for a scratch image
cargo test --workspace --all-features
cargo clippy --all-targets --all-features -- -D warnings   # treat every lint as an error, for CI
cargo tree -i openssl                                      # invert the tree: what pulls openssl in
cargo update -p serde --precise 1.0.203                    # pin one dependency to an exact version

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

struct Parser<'src> { input: &'src str, pos: usize }   // the struct cannot outlive the text it points into

fn first_word(s: &str) -> &str { s.split(' ').next().unwrap_or("") }   // elided: output borrows from s

const NAME: &'static str = "api";                      // lives for the whole program

let names: Vec<&str> = users.iter().map(|u| u.name.as_str()).collect();
let by_id: HashMap<i64, &User> = users.iter().map(|u| (u.id, u)).collect();
let joined = names.join(",");                                           // Vec<&str> and Vec<String> both work

for (i, line) in text.lines().enumerate().skip(1) {}                    // header skipped, 1-based i
let pairs: Vec<(u8, char)> = bytes.iter().copied().zip(chars).collect();
let windows = readings.windows(2).filter(|w| w[1] > w[0]).count();      // consecutive overlapping pairs
let chunks: Vec<Vec<Job>> = jobs.chunks(100).map(<[Job]>::to_vec).collect();
let flat: Vec<Item> = pages.into_iter().flat_map(|p| p.items).collect();
let total = costs.iter().fold(0u64, |acc, c| acc.saturating_add(*c));   // no overflow panic
let max_by_len = words.iter().max_by_key(|w| w.len());
let grouped = items.iter().fold(HashMap::<_, Vec<_>>::new(), |mut m, i| { m.entry(i.kind).or_default().push(i); m });
let sorted = { let mut v = items.clone(); v.sort_by(|a, b| b.score.total_cmp(&a.score)); v };   // floats need total_cmp

pub trait Backend {
    type Conn: Send;                                          // associated type, chosen by the implementor
    const NAME: &'static str;
    fn connect(&self) -> Result<Self::Conn, StoreError>;
    fn describe(&self) -> String { format!("backend {}", Self::NAME) }   // default method
}

impl std::fmt::Display for Host {                             // Display gives you to_string() for free
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { write!(f, "{}:{}", self.name, self.port) }
}

impl From<Row> for Host {                                     // From gives Into; ? uses From for errors
    fn from(r: Row) -> Self { Host { name: r.name, port: r.port } }
}

impl std::str::FromStr for Level {                            // "info".parse::<Level>()
    type Err = ParseError;
    fn from_str(s: &str) -> Result<Self, Self::Err> { match s { "info" => Ok(Level::Info), _ => Err(ParseError::Unknown(s.into())) } }
}

fn run(backends: &[Box<dyn Backend<Conn = PgConn>>]) {}       // trait objects need the associated type fixed

# Cargo.toml at the workspace root
[workspace]
members = ["crates/*"]
resolver = "3"                       # edition 2024 resolver; "2" for edition 2021

[workspace.package]
edition = "2024"
license = "MIT"

[workspace.dependencies]             # one version, inherited by members with `serde.workspace = true`
serde = { version = "1", features = ["derive"] }
tokio = { version = "1", features = ["rt-multi-thread", "macros", "signal"] }

[workspace.lints.clippy]
unwrap_used = "warn"

# crates/api/Cargo.toml
[features]
default = ["json"]
json = ["dep:serde_json"]            # dep: prefix: the feature enables an optional dependency without exposing it
metrics = []                         # gates #[cfg(feature = "metrics")] code only

[dependencies]
serde_json = { version = "1", optional = true }

cargo build -p api                                 # one workspace member
cargo test --workspace --no-default-features       # prove the crate compiles with nothing optional
cargo build --features metrics --no-default-features
cargo hack check --each-feature --no-dev-deps      # cargo-hack: every feature alone, catches missing cfg guards
cargo tree -e features -p api                      # which features are active and who enabled them
cargo metadata --format-version 1 | jq '.workspace_members'

[workspace.lints.clippy]
all = { level = "warn", priority = -1 }    # lower priority so the specific lints below override the group
pedantic = { level = "warn", priority = -1 }
module_name_repetitions = "allow"
missing_errors_doc = "allow"
unwrap_used = "warn"                        # restriction lint: forces expect() or ? in library code
dbg_macro = "warn"
todo = "warn"

[workspace.lints.rust]
unsafe_code = "forbid"
missing_debug_implementations = "warn"

cargo clippy --all-targets --all-features -- -D warnings   # CI: any warning fails
cargo clippy --fix --allow-dirty                            # apply machine-applicable suggestions in a dirty tree
cargo clippy -- -W clippy::pedantic 2>&1 | grep -c warning  # count before committing to a group

use tokio::sync::{mpsc, oneshot, watch, Semaphore};
use tokio::task::JoinSet;

let (tx, mut rx) = mpsc::channel::<Job>(256);              // bounded: send().await backpressures the producer
let (done_tx, done_rx) = oneshot::channel::<Result<(), Error>>();   // one reply
let (cfg_tx, cfg_rx) = watch::channel(Config::default());  // latest value, many readers: config reload

let mut set = JoinSet::new();
for id in ids {
    let client = client.clone();
    set.spawn(async move { fetch(&client, id).await });
}
while let Some(res) = set.join_next().await {
    match res {
        Ok(Ok(v)) => handle(v),
        Ok(Err(e)) => tracing::warn!(error = %e, "fetch failed"),   // the task's own error
        Err(join) if join.is_panic() => tracing::error!("task panicked"),
        Err(_) => {}                                                  // cancelled
    }
}

let sem = Arc::new(Semaphore::new(16));                    // bound concurrency across spawned tasks
let permit = sem.clone().acquire_owned().await?;           // held by the task; released on drop
tokio::spawn(async move { let _permit = permit; work().await });

let result = tokio::time::timeout(Duration::from_secs(5), call()).await;   // Err(Elapsed) on timeout
let handle = tokio::task::spawn_blocking(move || compress(&data));         // runs on the blocking pool

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

# Fastest feedback loop: recheck and retest on save
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 (nightly tool)
cargo +nightly udeps

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

# Expand a derive or macro to see the generated code
cargo expand --lib path::to::module

# Static musl binary, then confirm it has no dynamic links
cargo build --release --target x86_64-unknown-linux-musl && ldd target/x86_64-unknown-linux-musl/release/app

# Type-check the whole workspace without producing artefacts
cargo check --workspace --all-targets --all-features

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

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

# Run Miri to catch undefined behaviour in unsafe code
cargo +nightly miri test

# Print the exact toolchain in use, for a bug report or CI log
rustc -vV && cargo --version

# Run only tests whose name contains a substring, single-threaded, with logs
RUST_LOG=debug cargo test parse -- --test-threads=1 --nocapture

# Check the crate builds with the minimum supported Rust version declared in Cargo.toml
cargo +1.80 check --locked

# Symbolised backtrace on panic
RUST_BACKTRACE=1 cargo run

# Everything that would be published, to catch stray files
cargo package --list

# Build docs with private items and fail on broken intra-doc links
RUSTDOCFLAGS='-D warnings' cargo doc --no-deps --document-private-items

async fn retry<T, E, F, Fut>(attempts: u32, token: &CancellationToken, mut f: F) -> Result<T, E>
where
    F: FnMut() -> Fut,
    Fut: Future<Output = Result<T, E>>,
    E: std::fmt::Display,
{
    let mut delay = Duration::from_millis(200);
    for attempt in 1..=attempts {
        match f().await {
            Ok(v) => return Ok(v),
            Err(e) if attempt == attempts => return Err(e),
            Err(e) => tracing::warn!(attempt, error = %e, "retrying in {delay:?}"),
        }
        tokio::select! {
            _ = tokio::time::sleep(delay) => {}
            _ = token.cancelled() => break,
        }
        delay = (delay * 2).min(Duration::from_secs(10));
    }
    f().await                                                        // final attempt after a cancellation
}

let (tx, rx) = tokio::sync::mpsc::channel::<Job>(64);
let rx = Arc::new(tokio::sync::Mutex::new(rx));
let mut workers = JoinSet::new();
for _ in 0..8 {
    let rx = Arc::clone(&rx);
    workers.spawn(async move {
        loop {
            let job = { rx.lock().await.recv().await };              // guard dropped before processing
            match job { Some(j) => process(j).await, None => break }  // None: every sender is gone
        }
    });
}
for j in jobs { tx.send(j).await?; }
drop(tx);                                                            // signals completion
while workers.join_next().await.is_some() {}

#[derive(Debug, thiserror::Error)]
enum CallError {
    #[error("timed out after {0:?}")] Timeout(Duration),
    #[error(transparent)] Upstream(#[from] reqwest::Error),
}

async fn call(client: &reqwest::Client, url: &str, budget: Duration) -> Result<String, CallError> {
    tokio::time::timeout(budget, async { client.get(url).send().await?.error_for_status()?.text().await })
        .await
        .map_err(|_| CallError::Timeout(budget))?
}

#[derive(Debug, Clone, serde::Deserialize)]
#[serde(default, deny_unknown_fields)]
pub struct Config {
    pub listen: String,
    pub database_url: String,
    #[serde(with = "humantime_serde")] pub timeout: Duration,      // "5s" in the file
    pub workers: usize,
}
impl Default for Config {
    fn default() -> Self { Self { listen: "127.0.0.1:8080".into(), database_url: String::new(), timeout: Duration::from_secs(5), workers: 4 } }
}

pub fn load(path: &Path) -> anyhow::Result<Config> {
    let mut cfg: Config = match std::fs::read_to_string(path) {
        Ok(s) => toml::from_str(&s).with_context(|| format!("parsing {}", path.display()))?,
        Err(e) if e.kind() == std::io::ErrorKind::NotFound => Config::default(),
        Err(e) => return Err(e).context("reading config"),
    };
    if let Ok(v) = std::env::var("APP_DATABASE_URL") { cfg.database_url = v; }
    anyhow::ensure!(!cfg.database_url.is_empty(), "database_url is required");
    Ok(cfg)
}

let client = reqwest::Client::builder()
    .connect_timeout(Duration::from_secs(3))
    .timeout(Duration::from_secs(30))                    // whole request, including the body
    .pool_idle_timeout(Duration::from_secs(90))
    .pool_max_idle_per_host(32)
    .user_agent(concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION")))
    .build()?;                                            // Client is an Arc internally; clone freely

let token = CancellationToken::new();
let shutdown = {
    let token = token.clone();
    async move {
        let mut term = tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())?;
        tokio::select! { _ = tokio::signal::ctrl_c() => {}, _ = term.recv() => {} }
        tracing::info!("shutdown signal received");
        token.cancel();
        anyhow::Ok(())
    }
};
tokio::spawn(shutdown);

let server = axum::serve(listener, app).with_graceful_shutdown(token.clone().cancelled_owned());
tokio::time::timeout(Duration::from_secs(20), server).await??;   // give in-flight requests 20s

use tracing_subscriber::{fmt, EnvFilter, prelude::*};

tracing_subscriber::registry()
    .with(EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info,hyper=warn")))
    .with(fmt::layer().json().with_current_span(true).with_writer(std::io::stderr))
    .init();

#[tracing::instrument(skip(db), fields(user_id = %id), err)]   // err: logs the Err at ERROR level automatically
async fn load_user(db: &Pool, id: i64) -> Result<User, StoreError> {
    tracing::debug!("querying");
    db.get(id).await
}

#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize)]
#[serde(transparent)]
pub struct Port(u16);

impl TryFrom<u16> for Port {
    type Error = ConfigError;
    fn try_from(v: u16) -> Result<Self, Self::Error> { if v == 0 { Err(ConfigError::ZeroPort) } else { Ok(Port(v)) } }
}
impl<'de> serde::Deserialize<'de> for Port {
    fn deserialize<D: serde::Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
        Port::try_from(u16::deserialize(d)?).map_err(serde::de::Error::custom)
    }
}

let file = std::fs::File::open(path)?;
for line in std::io::BufReader::new(file).lines() {
    let line = line?;                                     // io::Error on a bad read, not a panic
    if line.starts_with('#') { continue; }
    handle(&line);
}

fn write_atomic(path: &Path, data: &[u8]) -> std::io::Result<()> {
    let dir = path.parent().unwrap_or(Path::new("."));
    let mut tmp = tempfile::NamedTempFile::new_in(dir)?;
    tmp.write_all(data)?;
    tmp.as_file().sync_all()?;
    tmp.persist(path).map(|_| ()).map_err(|e| e.error)   // rename; the temp file is removed on any earlier error
}

let out = tokio::time::timeout(
    Duration::from_secs(60),
    tokio::process::Command::new("pg_dump").arg("--format=custom").arg(&db_url).kill_on_drop(true).output(),
).await.context("pg_dump timed out")??;
anyhow::ensure!(out.status.success(), "pg_dump failed: {}", String::from_utf8_lossy(&out.stderr).trim());

#[test]
fn parses_durations() {
    let cases: &[(&str, Option<Duration>)] = &[
        ("5s", Some(Duration::from_secs(5))),
        ("2m", Some(Duration::from_secs(120))),
        ("", None),
        ("bad", None),
    ];
    for (input, want) in cases {
        assert_eq!(parse_duration(input).ok(), *want, "input {input:?}");
    }
}

let rules: Arc<RwLock<Arc<Rules>>> = Arc::new(RwLock::new(Arc::new(load_rules()?)));

// hot path: clone the inner Arc, drop the read lock immediately
let current = Arc::clone(&*rules.read().unwrap());
current.matches(&event);

// reload: build the new value outside the lock, then swap
let fresh = Arc::new(load_rules()?);
*rules.write().unwrap() = fresh;