Coding Rust

coding-rust

Purpose

This skill provides expertise in advanced Rust programming, focusing on core language features and ecosystem tools to build efficient, safe systems code.

When to Use

• When implementing memory-safe code with ownership, borrowing, or lifetimes to prevent common errors like data races.
• For projects requiring asynchronous programming with Tokio, error handling via anyhow/thiserror, or managing multi-crate setups with Cargo workspaces.
• In scenarios involving unsafe code for performance-critical sections, or defining custom behaviors with traits.

Key Capabilities

• Manage Rust's ownership model: Use references (&T) and lifetimes ('a) to borrow data without transferring ownership.
• Implement traits: Define and use trait objects for polymorphism, e.g., trait Debug { fn fmt(&self); }.
• Handle async with Tokio: Run asynchronous tasks using tokio::main and futures.
• Error management: Leverage anyhow for simple error wrapping and thiserror for custom error types.
• Cargo workspaces: Organize multi-package projects with Cargo.toml workspaces for dependency sharing.
• Unsafe operations: Use unsafe blocks for raw pointers or FFI, ensuring safety invariants are maintained.

Usage Patterns

• To handle ownership and borrowing, always prefer borrowing over cloning: Use &mut T for mutable references and ensure lifetimes match, e.g., in functions like fn borrow lifetimes<'a>(x: &'a i32) -> &'a i32.
• For async tasks, spawn Tokio runtimes: Use tokio::spawn to run futures concurrently, then await results in an async main function.
• Define traits for extensibility: Create a trait and implement it for structs, e.g., impl MyTrait for MyStruct { fn method() { ... } }.
• Set up Cargo workspaces: In the root Cargo.toml, add [workspace] section with members = ["crate1", "crate2"], then build with cargo build --workspace.
• Use anyhow for errors: Wrap errors with anyhow::Result and propagate them using ? operator.
• Employ unsafe sparingly: Wrap unsafe code in blocks like unsafe { *ptr = value; } and justify with comments.

Common Commands/API

• Cargo commands: Build with cargo build --release for optimized binaries; test with cargo test --workspace for all crates; add dependencies via cargo add tokio --features full.
• Tokio API: Start an async runtime with #[tokio::main] async fn main() { tokio::spawn(async { ... }); }; use channels for async communication, e.g., let (tx, rx) = tokio::sync::mpsc::channel(10);.
• Anyhow/thiserror: Define custom errors with #[derive(thiserror::Error)] enum MyError { ... }; handle in functions as fn example() -> anyhow::Result<()> { ... }.
• Ownership helpers: Use standard library functions like std::mem::drop to explicitly drop values, or std::borrow::Cow for owned/copied data.
• Config formats: Edit Cargo.toml for project settings, e.g., [dependencies] tokio = { version = "1.0", features = ["full"] }; use environment variables for secrets like RUST_BACKTRACE=1 for debugging.

Integration Notes

• Integrate with other tools: Use $RUSTUP_TOOLCHAIN env var to switch Rust versions, e.g., export RUSTUP_TOOLCHAIN=nightly for unstable features.
• For API keys in external integrations (e.g., if calling external services from Rust), set env vars like $MY_API_KEY and access via std::env::var("MY_API_KEY").unwrap().
• Combine with build tools: In CI/CD, run cargo fmt for code formatting and cargo clippy for lints before builds.
• Embed in projects: Add Tokio as a dependency in Cargo.toml, then import in code with use tokio::runtime::Runtime; let rt = Runtime::new().unwrap(); rt.block_on(async { ... });.
• Handle cross-crate dependencies in workspaces: Reference crates via paths, e.g., in Cargo.toml, use path = "../sibling_crate".

Error Handling

• Use anyhow for quick error propagation: Return anyhow::Result<T> from functions and use ? to handle errors, e.g., fn read_file() -> anyhow::Result<String> { std::fs::read_to_string("file.txt").context("Failed to read") }.
• Define custom errors with thiserror: Derive errors like #[derive(thiserror::Error, Debug)] enum AppError { #[error("IO error: {0}")] Io(#[from] std::io::Error), } and handle with match statements.
• In async contexts, use Tokio's error types: Await futures and handle errors with .await.map_err(|e| anyhow::Error::from(e)).
• Always check for panics in unsafe code: Use std::panic::catch_unwind around unsafe blocks to prevent crashes.

Concrete Usage Examples

1. Async HTTP server with Tokio: Create a simple server by adding Tokio to Cargo.toml, then write: use tokio::net::TcpListener; #[tokio::main] async fn main() -> anyhow::Result<()> { let listener = TcpListener::bind("127.0.0.1:8080").await?; loop { let (socket, _) = listener.accept().await?; tokio::spawn(handle_connection(socket)); } }.
2. Error handling in a CLI tool: Define errors and use anyhow: In Cargo.toml, add anyhow = "1.0" and thiserror = "1.0", then implement: use thiserror::Error; #[derive(Error, Debug)] enum Error { #[error("Parse error")] Parse, } fn main() -> anyhow::Result<()> { let input = std::env::args().nth(1)?; if input.parse::<u32>().is_err() { Err(Error::Parse)?; } Ok(()) }.

Graph Relationships

• Related to: coding (cluster), as it shares tags like "coding" and focuses on programming skills.
• Connected via: tags ["rust", "systems"], potentially linking to other Rust or systems programming skills.
• Dependencies: May integrate with skills in "coding" cluster, such as general coding tools for broader ecosystem support.