book

Idiomatic Rust

by Brenden Matthews

September 2024

Intermediate to advanced

256 pages

6h 40m

English

Manning Publications

Read now

Unlock full access

1.1 What this book covers1.2 What design patterns are1.3 Why this book is different1.4 Tools you’ll need
2.1 Generics2.1.1 A Turing-complete type system2.1.2 Why generics?2.1.3 Basics of generics2.1.4 Exploring Rust’s Option2.1.5 Marker structs and phantom types2.1.6 Generic parameter trait bounds2.2 Traits2.2.1 Why traits are not object-oriented programming2.2.2 What’s in a trait?2.2.3 Understanding traits by examining object-oriented code2.2.4 Combining generics and traits2.2.5 Deriving traits automatically2.2.6 Trait objects
3.1 A tour of pattern matching3.1.1 Basics of pattern matching3.1.2 Clean matches with the ? operator3.2 Functional Rust3.2.1 Basics of functional programming in Rust3.2.2 Closure variable capture3.2.3 Examining iterators3.2.4 Obtaining an iterator with iter(), into_iter(), and iter_mut()3.2.5 Iterator features
4.1 Resource acquisition is initialization4.1.1 Understanding RAII in C and C++4.1.2 A tour of RAII in Rust4.1.3 Summarizing RAII in Rust4.2 Passing arguments by value vs. reference4.2.1 Passing by value4.2.2 Passing by reference4.2.3 When to do what: Passing by value vs. reference4.3 Constructors4.4 Object-member visibility and access4.5 Error handling4.6 Global state4.6.1 lazy-static.rs4.6.2 once_cell4.6.3 static_init4.6.4 std::cell::OnceCell
5.1 Metaprogramming with macros5.1.1 A basic declarative macro in Rust5.1.2 When to use macros5.1.3 Using macros to write mini-DSLs5.1.4 Using macros for DRY5.2 Optional function arguments5.2.1 Examining optional arguments in Python5.2.2 Examining optional arguments in C++5.2.3 Optional arguments in Rust or the lack thereof5.2.4 Emulating optional arguments with traits5.3 Builder pattern5.3.1 Implementing the builder pattern5.3.2 Enhancing our builder with traits5.3.3 Enhancing our builder with macros5.4 Fluent interface pattern5.4.1 A fluent builder5.4.2 Test-driving our fluent builder5.5 Observer pattern5.5.1 Why not callbacks?5.5.2 Implementing an observer5.6 Command pattern5.6.1 Defining the command pattern5.6.2 Implementing the command pattern5.7 Newtype pattern
6.1 Meditate on good library design6.2 Do one thing, do it well, and do it correctly6.3 Avoid excessive abstraction6.4 Stick to basic types6.5 Use the tools6.6 Good artists copy; great artists steal (from the standard library)6.7 Document everything, and provide examples6.8 Don’t break the user’s code6.9 Think of the state6.10 Consider the aesthetics6.11 Examining Rust library ergonomics6.11.1 Revisiting linked lists6.11.2 Using rustdoc to improve our API design6.11.3 Improving our linked list with more tests6.11.4 Making our library easier for others to debug
7.1 Const generics7.2 Implementing traits for external crate types7.2.1 Wrapper structs7.2.2 Using Deref to unwrap a wrapped struct7.3 Extension traits7.4 Blanket traits7.5 Marker traits7.6 Struct tagging7.7 Reference objects
8.1 Trait state machine8.2 Coroutines8.3 Procedural macros8.4 Preludes
9.1 The benefits of immutability9.2 Why immutability is not a magic bullet9.3 How to think about immutable data9.4 Understanding immutability in Rust9.5 Reviewing the basics of immutability in Rust9.6 Using traits to make (almost) anything immutable9.7 Using Cow for immutability9.8 Using crates for immutable data structures9.8.1 Using im9.8.2 Using rpds
10.1 What is an antipattern?10.2 Using unsafe10.2.1 What does unsafe do?10.2.2 Where can you use unsafe?10.2.3 When should you use unsafe?10.2.4 Should you worry about unsafe?10.3 Using unwrap()10.4 Not using Vec10.5 Too many clones10.6 Using Deref to emulate polymorphism10.7 Global data and singletons10.8 Too many smart pointers10.9 Where to go from here
A.1 Installing tools for this bookA.1.1 Installing tools for macOS using HomebrewA.1.2 Installing tools for Linux systemsA.1.3 Installing tools for WindowsA.2 Managing rustc and other Rust components with rustupA.2.1 Installing rustc and other componentsA.2.2 Switching default toolchains with rustupA.2.3 Updating Rust components

Content preview from Idiomatic Rust

4 Introductory patterns

This chapter covers

Understanding resource acquisition is initialization
Passing arguments by value versus reference
Using constructors
Understanding object member visibility and access
Handling errors
Global state handling with lazy-static.rs, OnceCell, and static_init

Now we’re ready to dive into some more concrete patterns. We begin by reviewing some elementary topics: RAII, passing values, constructors, and visibility. Then we’ll move on to slightly more complex subjects: error handling and global variables. Although the chapter discusses many topics, it focuses on bite-size patterns, which we’ll use a lot.

This chapter also introduces crates, which are Rust libraries built by the community. The Rust language ...