Rust: Ownership, Traits and Cargo Reference Guide

# Install via rustup — the official toolchain manager
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Pin / switch toolchains
rustup default stable
rustup toolchain install nightly
rustup component add rustfmt clippy rust-analyzer

# Project setup
cargo new myapp                       # binary crate; add --lib for a library
cd myapp && cargo run                 # build + run
cargo add tokio --features full       # add a dependency (cargo-edit, bundled)
cargo build --release                 # optimized binary in target/release/

# Daily commands
cargo check                           # type-check without producing a binary
cargo test                            # run tests
cargo fmt && cargo clippy -- -D warnings
cargo bench                           # nightly only; or use criterion on stable

fn main() {
    // Move — owner changes, original is invalidated
    let s = String::from("hi");
    let t = s;                        // s is moved into t
    // println!("{s}");               // ERROR: borrow of moved value

    // Clone — explicit deep copy when you want both
    let a = String::from("hi");
    let b = a.clone();
    println!("{a} {b}");

    // Borrow — &T is a shared reference, &mut T is exclusive
    let mut v = vec![1, 2, 3];
    let r = &v;                       // many shared refs OK
    let m = &mut v;                   // exclusive — no other refs may exist now
    m.push(4);
    println!("{m:?}");                // [1, 2, 3, 4]

    // Slices borrow a contiguous view
    let nums = vec![10, 20, 30, 40];
    let head = &nums[..2];            // &[i32], no copy
    println!("{head:?}");

    // Strings: String is owned, &str is borrowed
    let owned: String = String::from("DevShelf");
    let borrowed: &str = &owned;      // implicit deref coercion
    print_label(borrowed);
}

fn print_label(s: &str) {             // takes any &str — cheap, no allocation
    println!("label: {s}");
}

use std::fmt::Display;

// A trait = interface. Methods can have default impls.
trait Greet {
    fn name(&self) -> &str;
    fn hello(&self) -> String { format!("hi {}", self.name()) }
}

struct Person { full_name: String }

impl Greet for Person {
    fn name(&self) -> &str { &self.full_name }
}

// Generic function — bounded by trait
fn shout(g: &T) -> String { g.hello().to_uppercase() }

// where-clause for multiple bounds
fn label(x: T) -> String where T: Display + Clone {
    format!("{} (cloned: {})", x.clone(), x)
}

// Trait objects = runtime polymorphism (dyn)
fn greet_many(gs: &[Box]) {
    for g in gs { println!("{}", g.hello()); }
}

fn main() {
    let p = Person { full_name: "Ada".into() };
    println!("{}", shout(&p));
    println!("{}", label(42));

    let people: Vec> = vec![
        Box::new(Person { full_name: "Ada".into() }),
        Box::new(Person { full_name: "Grace".into() }),
    ];
    greet_many(&people);
}

use std::fs;
use std::num::ParseIntError;
use thiserror::Error;

// Custom error enum — variants for each failure source
#[derive(Debug, Error)]
enum LoadError {
    #[error("io error: {0}")]
    Io(#[from] std::io::Error),
    #[error("parse error: {0}")]
    Parse(#[from] ParseIntError),
}

// ? propagates errors after From conversion
fn load_count(path: &str) -> Result {
    let contents = fs::read_to_string(path)?;     // io::Error → LoadError
    let n: u32 = contents.trim().parse()?;        // ParseIntError → LoadError
    Ok(n)
}

fn main() {
    match load_count("count.txt") {
        Ok(n)  => println!("count = {n}"),
        Err(e) => eprintln!("failed: {e}"),
    }

    // Option chaining — None short-circuits
    let first_word: Option<&str> = "hello world"
        .split_whitespace()
        .next();
    let upper = first_word.map(str::to_uppercase).unwrap_or_default();
    println!("{upper}");
}

fn main() {
    let scores = vec![88, 42, 95, 71, 63];

    // Lazy pipeline — nothing runs until a terminal op
    let top: Vec<_> = scores
        .iter()
        .copied()
        .filter(|n| *n >= 70)
        .map(|n| n + 5)
        .collect();
    println!("boosted passing: {top:?}");

    // fold for custom reductions
    let total: i32 = scores.iter().copied().fold(0, |acc, n| acc + n);
    println!("sum: {total}");

    // zip + enumerate for paired iteration
    let names = ["ada", "linus", "grace"];
    for (i, (name, score)) in names.iter().zip(scores.iter()).enumerate() {
        println!("{i}: {name} scored {score}");
    }

    // Option/Result combinators chain cleanly
    let parsed: i32 = "42"
        .parse()
        .map(|n: i32| n * 2)
        .unwrap_or(0);
    println!("parsed: {parsed}");
}

// Cargo.toml:
// [dependencies]
// tokio = { version = "1", features = ["full"] }
// reqwest = { version = "0.12", features = ["json"] }
// serde = { version = "1", features = ["derive"] }
// anyhow = "1"
// futures = "0.3"

use anyhow::Result;
use futures::future::join_all;
use serde::Deserialize;

#[derive(Debug, Deserialize)]
struct Repo { name: String, stargazers_count: u32 }

async fn fetch(client: &reqwest::Client, owner: &str) -> Result> {
    let url = format!("https://api.github.com/users/{owner}/repos?per_page=5");
    let repos = client.get(url)
        .header("User-Agent", "devshelf")
        .send().await?
        .error_for_status()?
        .json::>().await?;
    Ok(repos)
}

#[tokio::main]
async fn main() -> Result<()> {
    let client = reqwest::Client::new();
    let owners = ["rust-lang", "tokio-rs", "serde-rs"];

    // Fan out concurrently, join, collect
    let results = join_all(
        owners.iter().map(|o| fetch(&client, o))
    ).await;

    for (owner, res) in owners.iter().zip(results) {
        match res {
            Ok(repos) => for r in repos {
                println!("{owner}/{} ★{}", r.name, r.stargazers_count);
            },
            Err(e) => eprintln!("{owner}: {e}"),
        }
    }
    Ok(())
}