book

Programming Rust, 3rd Edition

by Jim Blandy, Jason Orendorff, Leonora F. S. Tindall

October 2026

Intermediate to advanced

748 pages

18h 51m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Preface
Who Should Read This BookWhy We Wrote This BookNavigating This BookConventions Used in This BookUsing Code ExamplesO’Reilly Online LearningHow to Contact UsAcknowledgments
1. Systems Programmers Can Have Nice Things
Rust Shoulders the Load for YouParallel Programming Is TamedAnd Yet Rust Is Still FastRust Makes Collaboration Easier
2. A Tour of Rust
rustup and CargoRust FunctionsWriting and Running Unit TestsHandling Command-Line ArgumentsServing Pages to the WebConcurrencyWhat the Mandelbrot Set Actually IsParsing Pair Command-Line ArgumentsMapping from Pixels to Complex NumbersPlotting the SetWriting Image FilesA Concurrent Mandelbrot ProgramSafety Is Invisible
3. Fundamental Types
Numeric TypesInteger TypesHandling Integer OverflowFloating-Point TypesThe bool TypeTuplesPointer TypesArrays, Vectors, and SlicesArraysVectorsSlicesString and Character TypesString and Character LiteralsCharacters and Strings in MemoryStringUsing StringsOther String-Like TypesType AliasesBeyond the Basics
4. Ownership and Moves
OwnershipMovesMore Operations That MoveMoves and Control FlowMoves and Indexed ContentCopy Types: The Exception to MovesRc and Arc: Shared Ownership
5. References
Reference BasicsWorking with ReferencesImplicit and Explicit ReferencesAssigning ReferencesReferences to ReferencesComparing ReferencesReferences Are Never NullBorrowing References to Arbitrary ExpressionsFat PointersReference SafetyBorrowing a Local VariableReceiving References as Function ArgumentsPassing References to FunctionsReturning ReferencesStructs Containing ReferencesDistinct Lifetime ParametersOmitting Lifetime ParametersSharing Versus MutationTaking Arms Against a Sea of Objects
6. Expressions
An Expression LanguageBlocksDeclarationsif and matchif letlet elseLoopsbreak and continue ExpressionsLabeled Blocksreturn ExpressionsWhy Rust Has loopconst and unsafe BlocksOperatorsFunction and Method CallsFields and ElementsReference OperatorsArithmetic, Bitwise, Comparison, and Logical OperatorsAssignmentType CastsClosuresOnward
7. Error Handling
PanicUnwindingAbortingThe Panic HookOther Panic MacrosResultCatching ErrorsPrinting ErrorsPropagating ErrorsResult MethodsResult Type AliasesWorking with Multiple Error TypesA Universal Error Type: anyhowDefining Custom Error TypesDealing with Errors That “Can’t Happen”Ignoring ErrorsHandling Errors in main()Why Results?
8. Crates and Modules
CratesEditionsRust VersionsBuild ProfilesModulesNested ModulesModules in Separate FilesPaths and ImportsThe Standard PreludeMaking use Declarations pubMaking Struct Fields pubConstants and StaticsTurning a Program into a LibraryThe src/bin DirectoryAttributesConditional CompilationThe Build EnvironmentIncluding FilesTests and DocumentationIntegration TestsDocumentationDoc-TestsSpecifying DependenciesVersionsCargo.lockBuild ScriptsPublishing Crates to crates.ioWorkspacesMore Nice Things
9. Structs
Defining StructsOther Kinds of StructsTuple StructsUnit-Like StructsStruct LayoutDefining Methods with implPassing Self as a Box, Rc, or ArcNon-Method Associated FunctionsAssociated ConstantsGeneric StructsGeneric Structs with Lifetime ParametersGeneric Structs with Constant ParametersDeriving Common Traits for Struct TypesInterior Mutability

10. Enums and Patterns
EnumsEnums with DataEnums in MemoryRich Data Structures Using EnumsGeneric EnumsPatternsLiterals, Variables, and Wildcards in PatternsTuple and Struct PatternsMatching ReferencesReference PatternsArray and Slice PatternsMatch GuardsMatching Multiple PossibilitiesBinding with @ PatternsWhere Patterns Are AllowedPopulating a Binary TreePublic Enums and CompatibilityThe Big Picture
11. Traits and Generics
Using TraitsUsing dynGeneric Functions and Type ParametersWhich to UseDefining and Implementing TraitsDefault MethodsTraits and Other People’s TypesSelf in TraitsSubtraitsAssociated FunctionsAssociated ConstantsFully Qualified Method CallsTraits That Define Relationships Between TypesAssociated Types (or How Iterators Work)Generic Traits (or How Operator Overloading Works)impl TraitLifetime Boundsuse BoundsReverse-Engineering BoundsTraits as a Foundation
12. Operator Overloading
Arithmetic and Bitwise OperatorsUnary OperatorsBinary OperatorsCompound Assignment OperatorsEquivalence ComparisonsThe Eq Trait (Or: Equality vs. NaN)Ordered ComparisonsIndex and IndexMutOther Operators
13. Utility Traits
DropSizedCloneCopyDeref and DerefMutDefaultAsRef and AsMutBorrow and BorrowMutFrom and IntoTryFrom and TryIntoToOwnedBorrow and ToOwned at Work: The Humble Cow
14. Closures
Capturing VariablesClosures That BorrowClosures That StealFunction and Closure TypesClosure PerformanceClosures and SafetyClosures That KillFnOnceFnMutCopy and Clone for ClosuresCallbacksUsing Closures Effectively
15. Iterators
The Iterator and IntoIterator TraitsCreating Iteratorsiter and iter_mut MethodsIntoIterator Implementationsfrom_fn and successorsdrain MethodsOther Iterator SourcesIterator Adaptersmap and filterfilter_map and flat_mapflattentake and take_whileskip and skip_whilepeekablefuseReversible Iterators and revinspectchainenumeratezipby_refcloned, copiedcycleConsuming IteratorsSimple Accumulation: count, sum, productmax, minmax_by, min_bymax_by_key, min_by_keyComparing Item Sequencesany and allposition, rposition, and ExactSizeIteratorfold and rfoldtry_fold and try_rfoldnth, nth_backlastfind, rfind, and find_mapBuilding Collections: collect and FromIteratorThe Extend Traitpartitionfor_each and try_for_eachImplementing Your Own Iterators
16. Collections
OverviewVec<T>Accessing ElementsIterationLength and CapacityGrowing and Shrinking VectorsSplittingSwappingFillingSorting and SearchingComparing SlicesRandom ElementsRust Rules Out Invalidation ErrorsVecDeque<T>BinaryHeap<T>HashMap<K, V> and BTreeMap<K, V>EntriesMap IterationHashSet<T> and BTreeSet<T>Set IterationWhen Equal Values Are DifferentWhole-Set OperationsHashingUsing a Custom Hashing AlgorithmBeyond the Standard Collections
17. Strings and Text
Some Unicode BackgroundASCII, Latin-1, and UnicodeUTF-8Text DirectionalityCharacters (char)Classifying CharactersHandling DigitsCase Conversion for CharactersConversions to and from IntegersString and strCreating String ValuesSimple InspectionAppending and Inserting TextRemoving and Replacing TextConventions for Searching and IteratingPatterns for Searching TextSearching and ReplacingIterating over TextTrimmingCase Conversion for StringsParsing Other Types from StringsConverting Other Types to StringsBorrowing as Other Text-Like TypesAccessing Text as UTF-8Producing Text from UTF-8 DataPutting Off AllocationStrings as Generic CollectionsFormatting ValuesFormatting Text ValuesFormatting NumbersFormatting Other TypesFormatting Values for DebuggingFormatting Pointers for DebuggingReferring to Arguments by Index or NameDynamic Widths and PrecisionsFormatting Your Own TypesUsing the Formatting Language in Your Own CodeRegular ExpressionsBasic Regex UseBuilding Regex Values Lazily
18. Input and Output
Readers and WritersReadersBuffered ReadersReading LinesCollecting LinesWritersFilesSeekingOther Reader and Writer TypesBinary Data, Compression, and SerializationFiles and DirectoriesOsStr and PathPath and PathBuf MethodsFilesystem Access FunctionsReading DirectoriesPlatform-Specific FeaturesNetworking
19. Threads
Fork-Join Parallelismspawn and joinError Handling Across ThreadsSharing Immutable Data Across ThreadsRayonRevisiting the Mandelbrot SetChannelsSending ValuesReceiving ValuesRunning the PipelineChannel Features and PerformanceThread Safety: Send and SyncPiping Almost Any Iterator to a ChannelBeyond PipelinesShared Mutable StateWhat Is a Mutex?Mutex<T>mut and MutexWhy Mutexes Are Not Always a Good IdeaDeadlockPoisoned MutexesMulticonsumer Channels Using MutexesRead/Write Locks (RwLock<T>)Condition Variables (Condvar)AtomicsGlobal VariablesThread-Local VariablesWhat Hacking Concurrent Code in Rust Is Like
20. Asynchronous Programming
What Asynchronous Code Looks LikeFuturesAsynchronous Function Future Typesasync BlocksFuture lifetimesSpawning Asynchronous TasksListing a Web Page’s Outgoing LinksSpidering the Web ConcurrentlyExtracting The Traversal’s ResultsWaiting Vs. BlockingAsynchronous Versions of Blocking ToolsTasks and ’staticTasks and SendAsynchronous ClosuresAsyncFnAsynchronous Functions In TraitsCancellationCancel safetyRacing futures with tokio::select!ShutdownAborting TasksShutdown SignalsCancellation tokensConclusion
21. Futures
The Future TraitImplementing and Instantiating FuturesHow Do We Know When to Poll?Invoking Wakers: spawn_blockingImplementing block_onThe Role of RuntimesImplementing I/O FuturesReactorsImplementating a ReactorCooperative MultitaskingTokio’s ExecutorPinningThe Two Life Stages of a FuturePinned PointersThe Unpin TraitConclusion
22. Macros
Macro BasicsBasics of Macro ExpansionUnintended ConsequencesRepetitionBuilt-In MacrosDebugging MacrosBuilding the json! MacroFragment TypesRecursion in MacrosUsing Traits with MacrosScoping and HygieneImporting and Exporting MacrosBeyond macro_rules!
23. Unsafe Code
Unsafe from What?unsafe BlocksExample: An Efficient ASCII String TypeUnsafe FunctionsMarking Unsafe CodeUndefined BehaviorUnsafe TraitsRaw PointersDereferencing Raw Pointers SafelyExample: RefWithFlagNull PointersType Sizes and AlignmentsPointer ArithmeticMoving into and out of MemoryExample: GapBufferPanic Safety in Unsafe CodeUnions
24. Foreign Functions
Finding Common Data RepresentationsDeclaring Foreign Functions and VariablesUsing Functions from LibrariesA Raw Interface to libgit2A Safe Interface to libgit2Conclusion
Index
About the Authors

Content preview from Programming Rust, 3rd Edition

About the Authors

Jim Blandy has been programming since 1981 and writing free software since 1990. He has been the maintainer of GNU Emacs and GNU Guile, and a maintainer of GDB, the GNU Debugger. He is one of the original designers of the Subversion version control system. Jim now works on Firefox’s graphics and rendering for Mozilla.

Jason Orendorff works on undisclosed Rust projects at GitHub. He previously worked on the SpiderMonkey JavaScript engine at Mozilla. He is interested in grammar, baking, time travel, and helping people learn about complicated topics.

Leonora Tindall is a type system enthusiast and software engineer who uses Rust, Elixir, and other advanced languages to build robust and resilient systems software in high-impact areas like healthcare and data ownership. She works on a variety of open source projects, from genetic algorithms that evolve programs in strange languages to the Rust core libraries and crate ecosystem, and enjoys the experience of contributing to supportive and diverse community projects. In her free time, Leonora builds electronics for audio synthesis and is an avid radio hobbyist. Her love of hardware extends to her software engineering practice as well. She has built applications software for LoRa radios in Rust and Python and uses software and DIY hardware to create experimental electronic music on a Eurorack synthesizer.

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: 9781098176228Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

Programming Rust, 3rd Edition

by Jim Blandy, Jason Orendorff, Leonora F. S. Tindall

About the Authors

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.