book

The Rust Programming Language, 3rd Edition

by Steve Klabnik, Carol Nichols, Chris Krycho

March 2026

Intermediate to advanced

624 pages

15h 47m

English

No Starch Press

Read now

Unlock full access

Praise for The Rust Programming Language
Title Page
Copyright
About the Authors and the Technical Reviewer
Foreword
Preface
Acknowledgments
Introduction
Who Rust Is ForTeams of DevelopersStudentsCompaniesOpen Source DevelopersPeople Who Value Speed and StabilityWho This Book Is ForHow to Use This BookResources and How to Contribute to This Book
1. Getting Started
InstallationInstalling rustup on Linux or macOSInstalling rustup on WindowsTroubleshootingUpdating and UninstallingReading the Local DocumentationUsing Text Editors and IDEsHello, World!Project Directory SetupRust Program BasicsAnatomy of a Rust ProgramCompilation and ExecutionHello, Cargo!Creating a Project with CargoBuilding and Running a Cargo ProjectBuilding for ReleaseLeveraging Cargo’s ConventionsSummary
2. Programming a Guessing Game
Setting Up a New ProjectProcessing a GuessStoring Values with VariablesReceiving User InputHandling Potential Failure with the Result TypePrinting Values with println! PlaceholdersTesting the First PartGenerating a Secret NumberIncreasing Functionality with a CrateGenerating a Random NumberComparing the Guess to the Secret NumberAllowing Multiple Guesses with LoopingQuitting After a Correct GuessHandling Invalid InputSummary

3. Common Programming Concepts
Variables and MutabilityDeclaring ConstantsShadowingData TypesScalar TypesCompound TypesFunctionsParametersStatements and ExpressionsFunctions with Return ValuesCommentsControl Flowif ExpressionsRepetition with LoopsSummary
4. Understanding Ownership
What Is Ownership?Ownership RulesVariable ScopeThe String TypeMemory and AllocationOwnership and FunctionsReturn Values and ScopeReferences and BorrowingMutable ReferencesDangling ReferencesThe Rules of ReferencesThe Slice TypeString SlicesOther SlicesSummary
5. Using Structs to Structure Related Data
Defining and Instantiating StructsUsing the Field Init ShorthandCreating Instances with Struct Update SyntaxCreating Different Types with Tuple StructsDefining Unit-Like StructsAn Example Program Using StructsRefactoring with TuplesRefactoring with StructsAdding Functionality with Derived TraitsMethodsMethod SyntaxMethods with More ParametersAssociated FunctionsMultiple impl BlocksSummary
6. Enums and Pattern Matching
Defining an EnumEnum ValuesThe Option EnumThe match Control Flow ConstructPatterns That Bind to ValuesThe Option<T> Match PatternMatches Are ExhaustiveCatch-All Patterns and the _ PlaceholderConcise Control Flow with if letStaying on the “Happy Path” with let...elseSummary
7. Packages, Crates, and Modules
Packages and CratesControl Scope and Privacy with ModulesPaths for Referring to an Item in the Module TreeExposing Paths with the pub KeywordStarting Relative Paths with superMaking Structs and Enums PublicBringing Paths into Scope with the use KeywordCreating Idiomatic use PathsProviding New Names with the as KeywordRe-exporting Names with pub useUsing External PackagesUsing Nested Paths to Clean Up use ListsImporting Items with the Glob OperatorSeparating Modules into Different FilesSummary
8. Common Collections
Storing Lists of Values with VectorsCreating a New VectorUpdating a VectorReading Elements of VectorsIterating Over the Values in a VectorUsing an Enum to Store Multiple TypesDropping a Vector Drops Its ElementsStoring UTF-8 Encoded Text with StringsDefining StringsCreating a New StringUpdating a StringIndexing into StringsSlicing StringsIterating Over StringsHandling the Complexities of StringsStoring Keys with Associated Values in Hash MapsCreating a New Hash MapAccessing Values in a Hash MapManaging Ownership in Hash MapsUpdating a Hash MapHashing FunctionsSummary
9. Error Handling
Unrecoverable Errors with the panic! MacroRecoverable Errors with ResultMatching on Different ErrorsPropagating ErrorsTo panic! or Not to panic!Examples, Prototype Code, and TestsWhen You Have More Information Than the CompilerGuidelines for Error HandlingCustom Types for ValidationSummary
10. Generic Types, Traits, and Lifetimes
Removing Duplication by Extracting a FunctionGeneric Data TypesIn Function DefinitionsIn Struct DefinitionsIn Enum DefinitionsIn Method DefinitionsPerformance of Code Using GenericsDefining Shared Behavior with TraitsDefining a TraitImplementing a Trait on a TypeUsing Default ImplementationsUsing Traits as ParametersReturning Types That Implement TraitsUsing Trait Bounds to Conditionally Implement MethodsValidating References with LifetimesDangling ReferencesThe Borrow CheckerGeneric Lifetimes in FunctionsLifetime Annotation SyntaxIn Function SignaturesRelationshipsIn Struct DefinitionsLifetime ElisionIn Method DefinitionsThe Static LifetimeGeneric Type Parameters, Trait Bounds, and LifetimesSummary
11. Writing Automated Tests
How to Write TestsStructuring Test FunctionsChecking Results with the assert! MacroTesting Equality with the assert_eq! and assert_ne! MacrosAdding Custom Failure MessagesChecking for Panics with the should_panic AttributeUsing Result<T, E> in TestsControlling How Tests Are RunRunning Tests in Parallel or ConsecutivelyShowing Function OutputRunning a Subset of Tests by NameIgnoring Tests Unless Specifically RequestedTest OrganizationUnit TestsIntegration TestsSummary
12. An I/O Project: Building a Command Line Program
Accepting Command Line ArgumentsReading the Argument ValuesSaving the Argument Values in VariablesReading a FileRefactoring to Improve Modularity and Error HandlingSeparating Concerns in Binary ProjectsFixing the Error HandlingExtracting Logic from mainSplitting Code into a Library CrateAdding Functionality with Test-Driven DevelopmentWriting a Failing TestWriting Code to Pass the TestWorking with Environment VariablesWriting a Failing Test for Case-Insensitive SearchImplementing the search_case_insensitive FunctionRedirecting Errors to Standard ErrorChecking Where Errors Are WrittenPrinting Errors to Standard ErrorSummary
13. Functional Language Features: Iterators and Closures
ClosuresCapturing the EnvironmentInferring and Annotating Closure TypesCapturing References or Moving OwnershipMoving Captured Values Out of ClosuresProcessing a Series of Items with IteratorsThe Iterator Trait and the next MethodMethods That Consume the IteratorMethods That Produce Other IteratorsClosures That Capture Their EnvironmentImproving Our I/O ProjectRemoving a clone Using an IteratorClarifying Code with Iterator AdaptersChoosing Between Loops and IteratorsPerformance in Loops vs. IteratorsSummary
14. More About Cargo and Crates.IO
Customizing Builds with Release ProfilesPublishing a Crate to Crates.ioMaking Useful Documentation CommentsExporting a Convenient Public APISetting Up a Crates.io AccountAdding Metadata to a New CratePublishing to Crates.ioPublishing a New Version of an Existing CrateDeprecating Versions from Crates.ioCargo WorkspacesCreating a WorkspaceCreating the Second Package in the WorkspaceInstalling Binaries with cargo installExtending Cargo with Custom CommandsSummary
15. Smart Pointers
Using Box<T> to Point to Data on the HeapStoring Data on the HeapEnabling Recursive Types with BoxesTreating Smart Pointers Like Regular ReferencesFollowing the Reference to the ValueUsing Box<T> Like a ReferenceDefining Our Own Smart PointerImplementing the Deref TraitUsing Deref Coercion in Functions and MethodsHandling Deref Coercion with Mutable ReferencesRunning Code on Cleanup with the Drop TraitA Reference-Counted Smart PointerSharing DataCloning to Increase the Reference CountThe Interior Mutability PatternEnforcing Borrowing Rules at RuntimeUsing Interior MutabilityAllowing Multiple Owners of Mutable DataReference Cycles Can Leak MemoryCreating a Reference CyclePreventing Reference Cycles Using Weak<T>Summary
16. Fearless Concurrency
Using Threads to Run Code SimultaneouslyCreating a New Thread with spawnWaiting for All Threads to FinishUsing move Closures with ThreadsTransfer Data Between Threads with Message PassingTransferring Ownership Through ChannelsSending Multiple ValuesCreating Multiple ProducersShared-State ConcurrencyControlling Access with MutexesComparing RefCell<T>/Rc<T> and Mutex<T>/Arc<T>Extensible Concurrency with Send and SyncTransferring Ownership Between ThreadsAccessing from Multiple ThreadsImplementing Send and Sync Manually Is UnsafeSummary
17. Fundamentals of Asynchronous Programming
Parallelism and ConcurrencyFutures and the Async SyntaxOur First Async ProgramDefining the page_title FunctionExecuting an Async Function with a RuntimeConcurrently Racing Two URLs Against Each OtherApplying Concurrency with AsyncCreating a New Task with spawn_taskSending Data Between Two TasksYielding Control to the RuntimeBuilding Our Own Async AbstractionsStreams: Futures in SequenceA Closer Look at the Traits for AsyncThe Future TraitThe Pin Type and the Unpin TraitThe Stream TraitFutures, Tasks, and ThreadsSummary
18. Object-Oriented Programming Features
Characteristics of Object-Oriented LanguagesObjects Contain Data and BehaviorEncapsulation That Hides Implementation DetailsInheritance as a Type System and as Code SharingUsing Trait Objects to Abstract Over Shared BehaviorDefining a Trait for Common BehaviorImplementing the TraitPerforming Dynamic DispatchImplementing an Object-Oriented Design PatternAttempting Traditional Object-Oriented StyleEncoding States and Behavior as TypesSummary
19. Patterns and Matching
All the Places Patterns Can Be Usedmatch Armslet StatementsConditional if let Expressionswhile let Conditional Loopsfor LoopsFunction ParametersRefutability: Whether a Pattern Might Fail to MatchPattern SyntaxMatching LiteralsMatching Named VariablesMatching Multiple PatternsMatching Ranges of ValuesDestructuring to Break Apart ValuesIgnoring Values in a PatternAdding Conditionals with Match GuardsUsing @ BindingsSummary
20. Advanced Features
Unsafe RustPerforming Unsafe SuperpowersDereferencing a Raw PointerCalling an Unsafe Function or MethodAccessing or Modifying a Mutable Static VariableImplementing an Unsafe TraitAccessing Fields of a UnionUsing Miri to Check Unsafe CodeUsing Unsafe Code CorrectlyAdvanced TraitsDefining Traits with Associated TypesUsing Default Generic Parameters and Operator OverloadingDisambiguating Between Identically Named MethodsUsing SupertraitsImplementing External Traits with the Newtype PatternAdvanced TypesType Safety and Abstraction with the Newtype PatternType Synonyms and Type AliasesThe Never Type That Never ReturnsDynamically Sized Types and the Sized TraitAdvanced Functions and ClosuresFunction PointersReturning ClosuresMacrosThe Difference Between Macros and FunctionsDeclarative Macros for General MetaprogrammingProcedural Macros for Generating Code from AttributesCustom derive MacrosAttribute-Like MacrosFunction-Like MacrosSummary
21. Final Project: Building a Multithreaded Web Server
Building a Single-Threaded Web ServerListening to the TCP ConnectionReading the RequestLooking More Closely at an HTTP RequestWriting a ResponseReturning Real HTMLValidating the Request and Selectively RespondingRefactoringFrom a Single-Threaded to a Multithreaded ServerSimulating a Slow RequestImproving Throughput with a Thread PoolGraceful Shutdown and CleanupImplementing the Drop Trait on ThreadPoolSignaling to the Threads to Stop Listening for JobsSummary
A. Keywords
Keywords Currently in UseKeywords Reserved for Future UseRaw Identifiers
B. Operators and Symbols
OperatorsNon-operator Symbols
C. Derivable Traits
Debug for Programmer OutputPartialEq and Eq for Equality ComparisonsPartialOrd and Ord for Ordering ComparisonsClone and Copy for Duplicating ValuesHash for Mapping a Value to a Value of Fixed SizeDefault for Default Values
D. Useful Development Tools
Automatic Formatting with rustfmtFix Your Code with rustfixMore Lints with ClippyIDE Integration Using rust-analyzer
E. Editions
Index

Content preview from The Rust Programming Language, 3rd Edition

4 UNDERSTANDING OWNERSHIP

Ownership is Rust’s most unique feature and has deep implications for the rest of the language. It enables Rust to make memory safety guarantees without needing a garbage collector, so it’s important to understand how ownership works. In this chapter, we’ll talk about ownership as well as several related features: borrowing, slices, and how Rust lays data out in memory.

What Is Ownership?

Ownership is a set of rules that govern how a Rust program manages memory. All programs have to manage the way they use a computer’s memory while running. Some languages have garbage collection that regularly looks for no-longer-used ...

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

The Rust Programming Language, 2nd Edition

Publisher Resources

ISBN: 0642572230241Errata Page

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Rust Programming Language, 3rd Edition

by Steve Klabnik, Carol Nichols, Chris Krycho

4 UNDERSTANDING OWNERSHIP

What Is Ownership?

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.