rust-patterns

Refactoring Rust code for memory safety involves applying idiomatic ownership and borrowing patterns to eliminate unnecessary cloning and unsafe code. This Skill provides structured architectural guidance to enforce zero-cost abstractions and maintainable crate structures during refactoring.

Handling errors idiomatically in Rust requires propagating failures using the Result and Option types instead of relying on exceptions. This Skill enforces standard Rust conventions for error propagation and type safety to ensure robust, maintainable applications.

Structuring a Rust crate using domain-driven design requires organizing modules around business domains and utilizing trait-based abstractions. This Skill offers architectural templates for module organization to ensure standard Rust conventions and maintainable codebases.

Idiomatic Rust provides efficient concurrency patterns that ensure memory safety without sacrificing performance in critical applications. This Skill guides developers in applying ownership rules to concurrent code, avoiding common pitfalls like data races.

Unnecessary cloning in Rust often occurs when ownership and borrowing rules are not applied idiomatically, leading to suboptimal memory usage. This Skill provides code review guidance to identify and refactor these patterns into zero-cost abstractions.

Yes, you can use this Skill to review your Rust module structure and suggest improvements based on domain-driven design principles. It applies architectural guidance and trait-based abstractions to ensure standard conventions for error propagation and type safety.