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

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
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
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
Variables and MutabilityConstantsShadowingData TypesScalar TypesCompound TypesFunctionsParametersStatements and ExpressionsFunctions with Return ValuesCommentsControl Flowif ExpressionsRepetition with LoopsSummary

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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
Keywords Currently in UseKeywords Reserved for Future UseRaw Identifiers
OperatorsNon-operator Symbols
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
Automatic Formatting with rustfmtFix Your Code with rustfixMore Lints with ClippyIDE Integration Using rust-analyzer

Content preview from The Rust Programming Language, 2nd Edition

About the Authors

Steve Klabnik was the lead for the Rust documentation team and was one of Rust’s core developers. A frequent speaker and a prolific open source contributor, he previously worked on projects such as Ruby and Ruby on Rails.

Carol Nichols is a member of the Rust Crates.io Team and a former member of the Rust Core Team. She’s a co-founder of Integer 32, LLC, the world’s first Rust-focused software consultancy. Nichols has also organized the Rust Belt Rust Conference.

About the Technical Reviewer

JT is a Rust core team member and the co-creator of the Rust error message format, Rust Language Server (RLS), and Nushell. They first started using Rust in 2011, and in 2016 joined Mozilla to work on Rust full-time, helping to shape its ...