book

Effective Rust

by David Drysdale

April 2024

Beginner to intermediate

298 pages

7h 38m

English

O'Reilly Media, Inc.

Read now

Unlock full access

Includes

Has Sandbox

Who This Book Is ForRust VersionNavigating This BookConventions Used in This BookO’Reilly Online LearningHow to Contact UsAcknowledgments
Item 1: Use the type system to express your data structuresFundamental TypesAggregate Typesenumsenums with FieldsUbiquitous enum TypesItem 2: Use the type system to express common behaviorFunctions and MethodsFunction PointersClosuresTraitsItem 3: Prefer Option and Result transforms over explicit match expressionsThings to RememberItem 4: Prefer idiomatic Error typesThe Error TraitMinimal ErrorsNested ErrorsTrait ObjectsLibraries Versus ApplicationsThings to RememberItem 5: Understand type conversionsUser-Defined Type ConversionsCastsCoercionItem 6: Embrace the newtype patternBypassing the Orphan Rule for TraitsNewtype LimitationsItem 7: Use builders for complex typesItem 8: Familiarize yourself with reference and pointer typesRust ReferencesPointer TraitsFat Pointer TypesMore Pointer TraitsSmart Pointer TypesItem 9: Consider using iterator transforms instead of explicit loopsIterator TraitsIterator TransformsIterator ConsumersBuilding Collections from Result ValuesLoop TransformationWhen Explicit Is Better
Item 10: Familiarize yourself with standard traitsCommon Standard TraitsStandard Traits Covered ElsewhereOperator OverloadsSummaryItem 11: Implement the Drop trait for RAII patternsItem 12: Understand the trade-offs between generics and trait objectsGenericsTrait ObjectsBasic ComparisonsMore Trait BoundsTrait Object SafetyTrade-OffsItem 13: Use default implementations to minimize required trait methods
Item 14: Understand lifetimesIntroduction to the StackEvolution of LifetimesScope of a LifetimeAlgebra of LifetimesLifetime Elision RulesThe 'static LifetimeLifetimes and the HeapLifetimes in Data StructuresAnonymous LifetimesThings to RememberItem 15: Understand the borrow checkerAccess ControlBorrow RulesOwner OperationsWinning Fights Against the Borrow CheckerThings to RememberItem 16: Avoid writing unsafe codeItem 17: Be wary of shared-state parallelismData RacesDeadlocksAdviceItem 18: Don’t panicItem 19: Avoid reflectionUpcasting in Future Versions of RustItem 20: Avoid the temptation to over-optimizeData Structures and AllocationWho’s Afraid of the Big Bad Copy?References and Smart Pointers
Item 21: Understand what semantic versioning promisesSemver EssentialsSemver for Crate AuthorsSemver for Crate UsersDiscussionItem 22: Minimize visibilityVisibility SyntaxVisibility SemanticsItem 23: Avoid wildcard importsItem 24: Re-export dependencies whose types appear in your APIItem 25: Manage your dependency graphVersion SpecificationSolving Problems with ToolingWhat to Depend OnThings to RememberItem 26: Be wary of feature creepConditional CompilationFeaturesThings to Remember
Item 27: Document public interfacesToolingAdditional Documentation LocationsPublished Crate DocumentationWhat Not to DocumentThings to RememberItem 28: Use macros judiciouslyDeclarative MacrosProcedural MacrosWhen to Use MacrosDisadvantages of MacrosAdviceItem 29: Listen to ClippyItem 30: Write more than unit testsUnit TestsIntegration TestsDoc TestsExamplesBenchmarksFuzz TestingTesting AdviceThings to RememberItem 31: Take advantage of the tooling ecosystemTools to RememberItem 32: Set up a continuous integration (CI) systemCI StepsCI PrinciplesPublic CI Systems
Item 33: Consider making library code no_std compatiblecoreallocWriting Code for no_stdFallible AllocationThings to RememberItem 34: Control what crosses FFI boundariesInvoking C Functions from RustAccessing C Data from RustLifetimesInvoking Rust from CThings to RememberItem 35: Prefer bindgen to manual FFI mappingsBeyond C

Overview

Rust's popularity is growing, due in part to features like memory safety, type safety, and thread safety. But these same elements can also make learning Rust a challenge, even for experienced programmers. This practical guide helps you make the transition to writing idiomatic Rust—while also making full use of Rust's type system, safety guarantees, and burgeoning ecosystem.

If you're a software engineer who has experience with an existing compiled language, or if you've struggled to convert a basic understanding of Rust syntax into working programs, this book is for you. By focusing on the conceptual differences between Rust and other compiled languages, and by providing specific recommendations that programmers can easily follow, Effective Rust will soon have you writing fluent Rust, not just badly translated C++.