Rust Knowledge

Rust Development Knowledge

Prerequisites

• Rust toolchain installed via rustup: curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
• Verify: rustc --version and cargo --version
• Recommended: rustup component add clippy rustfmt

Quick Reference

Essential Commands

Common Cargo Options

# Run specific test
cargo test test_name

# Run tests with output
cargo test -- --nocapture

# Check specific target
cargo check --target wasm32-unknown-unknown

# Build with features
cargo build --features "feature1 feature2"

# Build all targets
cargo build --all-targets

Official Documentation & WebFetch Verification

IMPORTANT: Use WebFetch to verify implementations against official Rust documentation. Always fetch and check documentation when:

• Implementing Rust language features (ownership, lifetimes, traits, etc.)
• Working with async/await patterns
• Using unsafe Rust
• Uncertain about correct syntax or behavior
• User asks about specific Rust language behavior

How to Use WebFetch

WebFetch URL: <documentation-url>
Prompt: "Extract the key concepts, syntax examples, and best practices for <topic>"

Rust Book Documentation (GitHub)

Base URL: https://raw.githubusercontent.com/rust-lang/book/main/src/

Additional Documentation Sources (WebFetch Compatible)

Use WebFetch with any of these URLs to verify patterns and implementations:

Crate Documentation (docs.rs)

For crate-specific documentation, use WebFetch with docs.rs:

Example: To verify tokio channel usage:

WebFetch URL: https://docs.rs/tokio/latest/tokio/sync/mpsc/index.html
Prompt: "Extract usage examples and best practices for tokio mpsc channels"

Reference Files

Detailed documentation for specific topics:

Included Scripts

Run scripts from the skill directory:

$CLAUDE_PLUGIN_ROOT/skills/rust-knowledge/scripts/new_project.sh my-project

Asset Templates

Common Patterns

Error Handling

// Using ? operator with Result
fn read_config(path: &str) -> Result<Config, ConfigError> {
    let content = fs::read_to_string(path)?;
    let config: Config = toml::from_str(&content)?;
    Ok(config)
}

// Custom error type with thiserror
#[derive(Debug, thiserror::Error)]
enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Parse error: {0}")]
    Parse(#[from] serde_json::Error),
}

Async Patterns

// Tokio async main
#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let result = fetch_data().await?;
    Ok(())
}

// Concurrent tasks
let (a, b) = tokio::join!(task_a(), task_b());

// Spawning tasks
let handle = tokio::spawn(async move {
    // background work
});

Builder Pattern

#[derive(Default)]
struct ServerBuilder {
    host: String,
    port: u16,
}

impl ServerBuilder {
    fn host(mut self, host: impl Into<String>) -> Self {
        self.host = host.into();
        self
    }

    fn port(mut self, port: u16) -> Self {
        self.port = port;
        self
    }

    fn build(self) -> Server {
        Server { host: self.host, port: self.port }
    }
}

Best Practices Summary

DO

• Use Result and ? for error propagation
• Prefer &str over String in function parameters
• Use clippy and fix all warnings
• Write unit tests alongside code
• Use #[must_use] for functions with important return values
• Prefer iterators over manual loops
• Use derive macros for common traits

DON'T

• Use .unwrap() in production code (prefer .expect() with context)
• Ignore clippy warnings
• Use unsafe without strong justification
• Clone unnecessarily (check if borrowing works)
• Use String when &str suffices
• Panic in library code (return Result instead)