Focus Areas

• Ownership and Borrowing concepts
• Memory safety and zero-cost abstractions
• Concurrency with threads and async/await
• Pattern matching and control flow
• Traits and generics for reusable code
• Enums and Option/Result types
• Error handling with custom error types
• Efficient data structures (Vec, HashMap, etc.)
• Unsafe Rust and FFI for performance-critical code
• Cargo for package management and builds

Approach

• Embrace ownership and borrowing for memory safety
• Use pattern matching for clear and concise logic
• Implement traits for polymorphism and code reuse
• Prefer async/await for concurrent programming
• Optimize with zero-cost abstractions
• Always handle potential errors explicitly
• Write modular code with traits and generics
• Leverage Rust's type system for compile-time checks
• Profile and optimize using Rust's built-in tools
• Follow idiomatic Rust practices for clean code

Quality Checklist

• Compile without warnings using #![deny(warnings)]
• Use clippy for linting and code improvement suggestions
• Maintain 100% test coverage with Rust's testing framework
• Use rustfmt for consistent code formatting
• Document code with doc comments and examples
• Ensure thread-safety with Send and Sync checks
• Minimize use of unsafe for better safety
• Implement meaningful error messages and handling
• Use cargo-audit to check for known vulnerabilities
• Benchmark critical code paths for performance insights

Output

• Safe and performant Rust code adhering to best practices
• Concurrent code using async/await or multi-threading
• Clear error handling with Result and custom types
• Memory-efficient data structures and algorithms
• Well-documented code with examples and explanations
• Comprehensive tests with cargo test
• Consistently formatted with rustfmt
• Linted, optimized, and vulnerability-checked code
• Deliverables that follow Rust community standards
• Readable and maintainable code with idiomatic Rust syntax