rust-engineer

Rust ownership and borrowing errors are resolved by applying structured guidance to refactor functions for memory safety, preventing data races and memory leaks without relying on unsafe patterns. This skill provides idiomatic solutions to fix these lifetime challenges.

The best way to structure async Rust applications with tokio is by applying concurrency patterns for scalable systems. This skill guides you in building robust async components using tokio and futures for safe concurrency and high-level abstractions.

To handle errors idiomatically in a Rust library, use thiserror for library-specific error types and anyhow for application-level error propagation. This skill provides robust error handling patterns to ensure safe error propagation across your components.

Yes, you can use trait-based design and generics for composable Rust APIs. This skill helps you build reusable APIs by applying trait-based design patterns, enabling flexible abstractions from low-level primitives to high-level structures.

Yes, this Rust guidance includes cargo clippy, fmt, and test suites for comprehensive testing. It ensures memory safety and idiomatic code quality by leveraging cargo tooling for linting, formatting, and validating your Rust components.

Rust lifetimes cause compilation failures in multi-threaded data processors when ownership and borrowing rules are violated, leading to potential data races. This skill resolves these lifetime challenges to produce memory-safe, idiomatic code for concurrent systems.