book

The Rust Programming Language, 2nd Edition

by Steve Klabnik, Carol Nichols

February 2023

Intermediate to advanced

560 pages

14h 34m

English

No Starch Press

Read now

Unlock full access

Title Page
Copyright
About the Authors
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
Chapter 1: Getting Started
InstallationInstalling rustup on Linux or macOSInstalling rustup on WindowsTroubleshootingUpdating and UninstallingLocal DocumentationHello, World!Creating a Project DirectoryWriting and Running a Rust ProgramAnatomy of a Rust ProgramCompiling and Running Are Separate StepsHello, Cargo!Creating a Project with CargoBuilding and Running a Cargo ProjectBuilding for ReleaseCargo as ConventionSummary
Chapter 2: Programming a Guessing Game
Setting Up a New ProjectProcessing a GuessStoring Values with VariablesReceiving User InputHandling Potential Failure with ResultPrinting Values with println! PlaceholdersTesting the First PartGenerating a Secret NumberUsing a Crate to Get More FunctionalityGenerating a Random NumberComparing the Guess to the Secret NumberAllowing Multiple Guesses with LoopingQuitting After a Correct GuessHandling Invalid InputSummary
Chapter 3: Common Programming Concepts
Variables and MutabilityConstantsShadowingData TypesScalar TypesCompound TypesFunctionsParametersStatements and ExpressionsFunctions with Return ValuesCommentsControl Flowif ExpressionsRepetition with LoopsSummary

Chapter 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
Chapter 5: Using Structs to Structure Related Data
Defining and Instantiating StructsUsing the Field Init ShorthandCreating Instances from Other Instances with Struct Update SyntaxUsing Tuple Structs Without Named Fields to Create Different TypesUnit-Like Structs Without Any FieldsAn Example Program Using StructsRefactoring with TuplesRefactoring with Structs: Adding More MeaningAdding Useful Functionality with Derived TraitsMethod SyntaxDefining MethodsMethods with More ParametersAssociated FunctionsMultiple impl BlocksSummary
Chapter 6: Enums and Pattern Matching
Defining an EnumEnum ValuesThe Option Enum and Its Advantages Over Null ValuesThe match Control Flow ConstructPatterns That Bind to ValuesMatching with Option<T>Matches Are ExhaustiveCatch-All Patterns and the _ PlaceholderConcise Control Flow with if letSummary
Chapter 7: Managing Growing Projects with Packages, Crates, and Modules
Packages and CratesDefining Modules to Control Scope and PrivacyPaths 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 Large use ListsThe Glob OperatorSeparating Modules into Different FilesSummary
Chapter 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 StringsWhat Is a String?Creating a New StringUpdating a StringIndexing into StringsSlicing StringsMethods for Iterating Over StringsStrings Are Not So SimpleStoring Keys with Associated Values in Hash MapsCreating a New Hash MapAccessing Values in a Hash MapHash Maps and OwnershipUpdating a Hash MapHashing FunctionsSummary
Chapter 9: Error Handling
Unrecoverable Errors with panic!Recoverable Errors with ResultMatching on Different ErrorsPropagating ErrorsTo panic! or Not to panic!Examples, Prototype Code, and TestsCases in Which You Have More Information Than the CompilerGuidelines for Error HandlingCreating Custom Types for ValidationSummary
Chapter 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 GenericsTraits: Defining Shared BehaviorDefining a TraitImplementing a Trait on a TypeDefault ImplementationsTraits as ParametersReturning Types That Implement TraitsUsing Trait Bounds to Conditionally Implement MethodsValidating References with LifetimesPreventing Dangling References with LifetimesThe Borrow CheckerGeneric Lifetimes in FunctionsLifetime Annotation SyntaxLifetime Annotations in Function SignaturesThinking in Terms of LifetimesLifetime Annotations in Struct DefinitionsLifetime ElisionLifetime Annotations in Method DefinitionsThe Static LifetimeGeneric Type Parameters, Trait Bounds, and Lifetimes TogetherSummary
Chapter 11: Writing Automated Tests
How to Write TestsThe Anatomy of a Test FunctionChecking Results with the assert! MacroTesting Equality with the assert_eq! and assert_ne! MacrosAdding Custom Failure MessagesChecking for Panics with should_panicUsing Result<T, E> in TestsControlling How Tests Are RunRunning Tests in Parallel or ConsecutivelyShowing Function OutputRunning a Subset of Tests by NameIgnoring Some Tests Unless Specifically RequestedTest OrganizationUnit TestsIntegration TestsSummary
Chapter 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 HandlingSeparation of Concerns for Binary ProjectsFixing the Error HandlingExtracting Logic from mainSplitting Code into a Library CrateDeveloping the Library’s Functionality with Test-Driven DevelopmentWriting a Failing TestWriting Code to Pass the TestWorking with Environment VariablesWriting a Failing Test for the Case-Insensitive Search FunctionImplementing the search_case_insensitive FunctionWriting Error Messages to Standard Error Instead of Standard OutputChecking Where Errors Are WrittenPrinting Errors to Standard ErrorSummary
Chapter 13: Functional Language Features: Iterators and Closures
Closures: Anonymous Functions That Capture Their EnvironmentCapturing the Environment with ClosuresClosure Type Inference and AnnotationCapturing References or Moving OwnershipMoving Captured Values Out of Closures and the Fn TraitsProcessing a Series of Items with IteratorsThe Iterator Trait and the next MethodMethods That Consume the IteratorMethods That Produce Other IteratorsUsing Closures That Capture Their EnvironmentImproving Our I/O ProjectRemoving a clone Using an IteratorMaking Code Clearer with Iterator AdaptersChoosing Between Loops and IteratorsComparing Performance: Loops vs. IteratorsSummary
Chapter 14: More About Cargo and Crates.io
Customizing Builds with Release ProfilesPublishing a Crate to Crates.ioMaking Useful Documentation CommentsExporting a Convenient Public API with pub useSetting Up a Crates.io AccountAdding Metadata to a New CratePublishing to Crates.ioPublishing a New Version of an Existing CrateDeprecating Versions from Crates.io with cargo yankCargo WorkspacesCreating a WorkspaceCreating the Second Package in the WorkspaceInstalling Binaries with cargo installExtending Cargo with Custom CommandsSummary
Chapter 15: Smart Pointers
Using Box<T> to Point to Data on the HeapUsing Box<T> to Store Data on the HeapEnabling Recursive Types with BoxesTreating Smart Pointers Like Regular References with DerefFollowing the Pointer to the ValueUsing Box<T> Like a ReferenceDefining Our Own Smart PointerImplementing the Deref TraitImplicit Deref Coercions with Functions and MethodsHow Deref Coercion Interacts with MutabilityRunning Code on Cleanup with the Drop TraitRc<T>, the Reference Counted Smart PointerUsing Rc<T> to Share DataCloning an Rc<T> Increases the Reference CountRefCell<T> and the Interior Mutability PatternEnforcing Borrowing Rules at Runtime with RefCell<T>Interior Mutability: A Mutable Borrow to an Immutable ValueAllowing Multiple Owners of Mutable Data with Rc<T> and RefCell<T>Reference Cycles Can Leak MemoryCreating a Reference CyclePreventing Reference Cycles Using Weak<T>Summary
Chapter 16: Fearless Concurrency
Using Threads to Run Code SimultaneouslyCreating a New Thread with spawnWaiting for All Threads to Finish Using join HandlesUsing move Closures with ThreadsUsing Message Passing to Transfer Data Between ThreadsChannels and Ownership TransferenceSending Multiple Values and Seeing the Receiver WaitingCreating Multiple Producers by Cloning the TransmitterShared-State ConcurrencyUsing Mutexes to Allow Access to Data from One Thread at a TimeSimilarities Between RefCell<T>/Rc<T> and Mutex<T>/Arc<T>Extensible Concurrency with the Send and Sync TraitsAllowing Transference of Ownership Between Threads with SendAllowing Access from Multiple Threads with SyncImplementing Send and Sync Manually Is UnsafeSummary
Chapter 17: 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 That Allow for Values of Different TypesDefining a Trait for Common BehaviorImplementing the TraitTrait Objects Perform Dynamic DispatchImplementing an Object-Oriented Design PatternDefining Post and Creating a New Instance in the Draft StateStoring the Text of the Post ContentEnsuring the Content of a Draft Post Is EmptyRequesting a Review Changes the Post’s StateAdding approve to Change the Behavior of contentTrade-offs of the State PatternSummary
Chapter 18: Patterns and Matching
All the Places Patterns Can Be Usedmatch ArmsConditional if let Expressionswhile let Conditional Loopsfor Loopslet StatementsFunction ParametersRefutability: Whether a Pattern Might Fail to MatchPattern SyntaxMatching LiteralsMatching Named VariablesMultiple PatternsMatching Ranges of Values with ..=Destructuring to Break Apart ValuesIgnoring Values in a PatternExtra Conditionals with Match Guards@ BindingsSummary
Chapter 19: Advanced Features
Unsafe RustUnsafe SuperpowersDereferencing a Raw PointerCalling an Unsafe Function or MethodAccessing or Modifying a Mutable Static VariableImplementing an Unsafe TraitAccessing Fields of a UnionWhen to Use Unsafe CodeAdvanced TraitsAssociated TypesDefault Generic Type Parameters and Operator OverloadingDisambiguating Between Methods with the Same NameUsing SupertraitsUsing the Newtype Pattern to Implement External TraitsAdvanced TypesUsing the Newtype Pattern for Type Safety and AbstractionCreating Type Synonyms with Type AliasesThe Never Type That Never ReturnsDynamically Sized Types and the Sized TraitAdvanced Functions and ClosuresFunction PointersReturning ClosuresMacrosThe Difference Between Macros and FunctionsDeclarative Macros with macro_rules! for General MetaprogrammingProcedural Macros for Generating Code from AttributesHow to Write a Custom derive MacroAttribute-Like MacrosFunction-Like MacrosSummary
Chapter 20: Final Project: Building a Multithreaded Web Server
Building a Single-Threaded Web ServerListening to the TCP ConnectionReading the RequestA Closer Look at an HTTP RequestWriting a ResponseReturning Real HTMLValidating the Request and Selectively RespondingA Touch of RefactoringTurning Our Single-Threaded Server into 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
Appendix A: Keywords
Keywords Currently in UseKeywords Reserved for Future UseRaw Identifiers
Appendix B: Operators and Symbols
OperatorsNon-operator Symbols
Appendix 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
Appendix D: Useful Development Tools
Automatic Formatting with rustfmtFix Your Code with rustfixMore Lints with ClippyIDE Integration Using rust-analyzer
Appendix E: Editions
Index

Content preview from The Rust Programming Language, 2nd Edition

18 Patterns and Matching

Patterns are a special syntax in Rust for matching against the structure of types, both complex and simple. Using patterns in conjunction with match expressions and other constructs gives you more control over a program’s control flow. A pattern consists of some combination of the following:

Literals
Destructured arrays, enums, structs, or tuples
Variables
Wildcards
Placeholders

Some example patterns include x, (a, 3), and Some(Color::Red). In the contexts in which patterns are valid, these components describe the shape of data. Our program then matches values against the patterns to determine whether it has the ...

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: 9781098156817

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

The Rust Programming Language, 2nd Edition

by Steve Klabnik, Carol Nichols

18 Patterns and Matching

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.