implementation

Core Principles

1. Follow the Design: Implement according to approved architecture
2. Test Everything: No code without corresponding tests
3. Zero Warnings: Code must compile without warnings or linting issues
4. Document Public APIs: All public items have documentation

Primary Responsibilities

1. Code Implementation
   • Write idiomatic Rust code
   • Follow project coding standards
   • Implement error handling with proper types
   • Use appropriate abstractions without over-engineering
2. Testing
   • Unit tests for all public functions
   • Integration tests for module interactions
   • Property-based tests for complex logic
   • Documentation tests for examples
3. Documentation
   • Rustdoc comments for all public items
   • Examples in documentation
   • Module-level documentation
   • README updates when needed
4. Code Quality
   • Pass

     cargo clippy

     with no warnings
   • Pass

     cargo fmt

     check
   • Handle all error cases explicitly
   • No unwrap() in production code (except tests)

Implementation Checklist

[ ] Code compiles without warnings
[ ] All clippy lints pass
[ ] Code is formatted with rustfmt
[ ] Unit tests written and passing
[ ] Integration tests if applicable
[ ] Documentation for public API
[ ] Error handling is complete
[ ] No TODO comments left unaddressed
[ ] CHANGELOG updated if needed

Rust Patterns

Error Handling

// Use thiserror for library errors
#[derive(Debug, thiserror::Error)]
pub enum MyError {
    #[error("failed to process: {0}")]
    Processing(String),
    #[error(transparent)]
    Io(#[from] std::io::Error),
}

// Use anyhow in applications
fn main() -> anyhow::Result<()> {
    // ...
}

Builder Pattern

#[derive(Default)]
pub struct ConfigBuilder {
    timeout: Option<Duration>,
    retries: Option<u32>,
}

impl ConfigBuilder {
    pub fn timeout(mut self, timeout: Duration) -> Self {
        self.timeout = Some(timeout);
        self
    }

    pub fn build(self) -> Config {
        Config {
            timeout: self.timeout.unwrap_or(Duration::from_secs(30)),
            retries: self.retries.unwrap_or(3),
        }
    }
}

Async Patterns

// Prefer tokio for async runtime
use tokio::sync::mpsc;

// Use channels for communication
async fn worker(mut rx: mpsc::Receiver<Task>) {
    while let Some(task) = rx.recv().await {
        process(task).await;
    }
}

Technology Stack

• Async Runtime: tokio
• Serialization: serde with appropriate format (JSON, MessagePack, etc.)
• HTTP: reqwest for client, axum for server
• CLI: clap with derive macros
• Logging: tracing ecosystem
• Testing: built-in + proptest for property tests

Code Style

• Line length: 100 characters
• Use

  Self

  in impl blocks
• Prefer explicit types in function signatures
• Use

  ?

  operator for error propagation
• Group imports: std, external crates, internal modules
• Add

  #[must_use]

  to functions returning values that shouldn't be ignored

Constraints

• Never skip tests
• Never use

  unwrap()

  or

  expect()

  in library code
• Never ignore errors silently
• Always handle all match arms
• Avoid

  unsafe

  unless absolutely necessary (and document why)
• Keep functions under 50 lines when possible

Success Metrics

• Zero compiler warnings
• Zero clippy warnings
• Test coverage > 80%
• All documentation examples compile
• No panics in production code paths