book

Idiomatic Rust

Name: Idiomatic Rust
Author: Brenden Matthews
ISBN: 9781633437463

by Brenden Matthews

September 2024

Intermediate to advanced

256 pages

6h 40m

English

Manning Publications

Audiobook available

Read now

Unlock full access

copyright
contents
Idiomatic Rust
dedication
preface
acknowledgments
about this book
about the author
about the cover illustration
Part 1 Building blocks

1 Rust-y patterns
1.1 What this book covers1.2 What design patterns are1.3 Why this book is different1.4 Tools you’ll need
2 Rust’s basic building blocks
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 Code flow
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
Part 2 Core patterns
4 Introductory patterns
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 Design patterns: Beyond the basics
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 Designing a library
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
Part 3 Advanced patterns
7 Using traits, generics, and structs for specialized tasks
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 State machines, coroutines, macros, and preludes
8.1 Trait state machine8.2 Coroutines8.3 Procedural macros8.4 Preludes
Part 4 Problem avoidance
9 Immutability
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 Antipatterns
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
appendix Installing Rust
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

2 Rust’s basic building blocks

This chapter covers

Exploring the core Rust patterns
Diving into Rust generics
Exploring traits
Combining generics and traits
Deriving traits automatically

In this chapter, I’ll introduce and discuss some of Rust’s most important abstractions and features, which I call building blocks and which serve as the foundation of nearly all design patterns in Rust. Reviewing and understanding these building blocks before diving deeper into other patterns is crucial. For some readers, this chapter may appear to be a review of language basics; it sets the stage for more advanced topics, however, so I recommend that you don’t skip it.

We’ll begin by discussing generics and traits in Rust. They are the core building ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781633437463Publisher Support Publisher Website

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Idiomatic Rust

by Brenden Matthews