- ホーム
- > 洋書
- > 英文書
- > Computer / Languages
Full Description
Write safer, more maintainable Rust code by identifying anti-patterns, applying idiomatic design patterns tailored to ownership, borrowing, and the type system, and learning when to adapt or avoid traditional solutions
Key Features
Leverage traits, ownership, borrowing, and lifetimes to structure expressive, modular Rust code
Avoid common anti-patterns and design pitfalls with clear Rust-specific guidance
Solve real-world problems using Rust's type system, functional idioms, and architecture patterns
Book DescriptionMany Rust developers run into problems when they try to apply familiar object-oriented or cross-language patterns to Rust projects. These mismatches often lead to confusing compiler errors, awkward workarounds, or brittle code. This book helps you avoid those traps by thinking in Rust and designing software that embraces ownership, borrowing, and type safety.
The book begins with anti-patterns and common mistakes Rust developers often encounter, including misusing object-oriented thinking, over-relying on Clone, or treating the borrow checker as an obstacle. It then guides you through creational, structural, and behavioral patterns adapted to the language, illustrating how traditional approaches must be rethought for Rust.
You'll explore architectural patterns that support clean module design, learn how to use the type system to encode program logic, and discover Rust-native techniques such as TypeState and RAII. The final chapters synthesize these ideas into a Rust-centric design mindset that helps you build software more effectively.
By the end of this book, you'll know how to avoid costly mistakes, apply effective patterns confidently, and design Rust applications that are clean, scalable, and reliable.What you will learn
Design maintainable applications using idiomatic Rust patterns
Recognize common anti-patterns that lead to messy or inefficient code
Adapt classic creational, structural, and behavioral patterns to Rust
Leverage the type system to catch logic errors at compile time
Structure code effectively with modules, traits, and clear interfaces
Work with ownership, borrowing, and the type system to simplify data handling
Implement functional techniques for clearer, expressive Rust code
Who this book is forRust developers ready to move beyond the basics and improve how they design and structure code will benefit from this book. If you're comfortable building simple applications and using tools like Cargo, this book will help you write cleaner, more idiomatic, and reliable software.
It's ideal for those looking to understand which patterns work in Rust, how to avoid common traps, and how to tackle more complex, real-world projects with confidence.
Contents
Table of Contents
Why is Rust Different?
Anti-Pattern: Designing for Object Orientation
Anti-Pattern: Using Clone & Rc Everywhere
Don't Fight the Borrow Checker
Creational Patterns: Making Things
Structural Patterns: Connecting & Aggregating
Behavioural Patterns 1: Taking Actions
Behavioural Patterns 2: Keeping Track
Architectural Patterns
Patterns that Leverage the Type System
Patterns from Functional Programming
Patterns that use Unique Rust Features
Leaning into Rust
