rust-unofficialpatterns

0

Patterns

A catalogue of Rust design patterns, anti-patterns and idioms

Rust Pattern Collections - Serves as the primary Rust design pattern reference with adapted patterns and idioms.

Code Quality and Linting - Documents lint-driven code quality practices enforced at build time.

Pattern Catalogues - Curates a collection of reusable design patterns, anti-patterns, and idioms for Rust.

Lint Denials & Warnings - Provides instructions for controlling Rust compiler warnings and lint denials to enforce code quality.

Rust Idiom Collections - Documents Rust community idioms for writing idiomatic, maintainable code.

Deterministic Cleanup Patterns - Documents ownership-based resource management patterns for deterministic cleanup.

Type-State Patterns - Documents type-state programming patterns that encode state transitions in the type system.

Anti-Pattern References - Provides a reference for Rust anti-patterns to discourage problematic practices.

Rust Anti-Pattern Detection - Provides guidance on detecting and avoiding Rust anti-patterns.

Rust Anti-Pattern Guides - Documents common Rust anti-patterns to avoid for better code quality.

Design Patterns - Catalogs proven design solutions for recurring software engineering problems.

Rust-Specific Adaptations - Provides Rust-specific adaptations of design patterns leveraging ownership and borrowing.

Rust Conventions - Documents Rust community conventions for writing idiomatic code.

Type System Enforcements - Provides compile-time enforcement of design patterns through Rust's type system and linting.

Zero-Cost Polymorphism - Demonstrates trait-based abstraction patterns for zero-cost polymorphism.

Zero-Cost Abstraction Patterns - Documents zero-cost abstraction patterns that compile to efficient machine code.

Selective Deny Configurations - Documents how to selectively deny specific lints as errors in Rust.

Learning Resource Curation - Curates books, talks, and guidelines for learning Rust programming techniques.

Rust Lint Management - Documents Rust compiler warning and lint management strategies.

Warning-as-Error Enforcements - Documents how to enforce strict compiler warnings as errors during Rust builds.

Interface-Based Decoupling - Promotes relying on abstract interfaces rather than concrete implementations to reduce coupling.

Design by Contract - Defines formal preconditions, postconditions, and invariants to guarantee correct component interaction.

Encapsulation & Abstraction - Bundles data with methods and restricts direct access to prevent unauthorized modification.

Lint Denial Overrides - Documents how to override lint denials at build time for flexibility.

Command Query Separation - Distinguishes functions that change state from those that return data to prevent side effects in queries.

Composition Over Inheritance - Advocates reusing behavior by containing instances rather than inheriting from a base class.

Interface Segregation Principles - Provides many client-specific interfaces instead of one general-purpose interface to avoid forcing dependencies.

Single Responsibility Principles - Ensures each module has only one reason to change, aligning with a single part of the specification.

Rust Adaptations - Adapts general design principles like composition over inheritance and design by contract for Rust.