Recipe	Crates	Categories
Generate Random Numbers
Generate Random Numbers Within a Range
Generate Random Numbers Within a Given Distribution
Generate Random Values of a Custom Type
Create Random Passwords from a Set of Alphanumeric Characters
Create Random Passwords from a Set of User-defined Characters
fastrand

Recipe	Crates	Categories
Sort a Vector of Integers
Sort a Vector of Floats
Sort a Vector of Structs

Recipe	Crates	Categories
priority-queue

Recipe	Crates	Categories
Define and Operate on a Type Represented as a Bitfield
flagset
bitvec

Recipe	Crates	Categories
BTreeMap<K, V>
BTreeSet<T>

Recipe	Crates	Categories
Manipulate Graphs with petgraph

Recipe	Crates
Store Key-Value Pairs into a HashMap
Store Unique Items in a HashSet
Use a Custom Type as the Key of a HashMap
Use a Custom Hash Function with HashMap and HashSet

Recipe	Crates	Categories
Heapless

Recipe	Crates	Categories
Stored Data in a Linked List

Recipe	Crates	Categories
Store Data in an Insertion-ordered Map
Store Data in a multimap
Store Collections of Objects that Need Stable, Safe References

Recipe	Crates	Categories
arrayvec
smallvec
tinyvec

Recipe	Crates	Categories
Implement a Queue Using VecDeque
Implement a Stack Using Vec

Recipe	Crates
String and &str
Print and Format Strings
Concatenate Strings

Recipe	Crates	Categories
Generate and Parse UUIDs

Recipe	Crates
Store Homogeneous Data in a Contiguous, Growable Array: Vec
Vec Memory Allocation

Recipe	Crates	Categories
Get the Current Working Directory
remove_dir_all

Recipe	Crates	Categories
Find Files Modified in the Last 24 Hours
Find Loops in a Given Path
Recursively Find Duplicate File Names
Recursively Find All Files with a Given Predicate
Traverse Directories While Skipping Dotfiles
Walk the Filesystem While Respecting Ignore Files
Recursively Calculate File Sizes at a Given Depth
Find All Files with a Given Extension Recursively
Find All Files with Given Pattern, Ignoring Filename Case
globset

Recipe	Crates	Categories
Watch Files or Directories and Execute a Function When They Change

Recipe	Crates	Categories
Read Lines of Strings from a File
Avoid Writing and Reading from the Same File
Access a File Randomly Using a Memory Map

Recipe	Crates	Categories
Create Temporary Files or Temporary Directories

Recipe	Crates	Categories
dirs
directories
Open a File or URL using the Program Configured on your System

Recipe	Crates	Categories
Abstract over Different Number Types
Use Big Integers
Use Big Decimals
Sort Floats
num-bigint
num
rug
typenum

Recipe	Crates	Categories
Create Complex Numbers
Add Complex Numbers
Use Mathematical Functions on Complex Numbers

Recipe	Crates	Categories
Calculate Vector Norms
Add Matrices
Multiply Matrices
Multiply a Scalar with a Vector and a Matrix
Invert a Matrix
Compare Vectors
(De)serialize a Matrix

Recipe	Crates	Categories
Calculate Measures of Central Tendency
Compute the Standard Deviation

Recipe	Crates	Categories
Calculate the Side Length of a Triangle
Verify that tan is Equal to sin Divided by cos
Calculate the Distance Between two Points on Earth

Organize the Code of a Simple Library
Organize the Code of a Complex Library
Less Common Code Organizations
Flatten the Module Hierarchy Using Reexports
Create a Prelude for Commonly Used Items of Your Library
Organize the Code of a Binary Crate
Organize Large Projects Using a Workspace

Use Items from External Crates (Dependencies) in your Code

Structure your Code into Modules
Split your Code into Several Files
Access Items Within Modules via Paths
Use Modules to Hide Implementation Details

Name your Functions, Types, etc. (Naming Conventions)
Decide Between as_* vs to_* vs into_* for Conversion Methods
Name Getters
Name Iterators

Avoid Writing Full Paths with the use Keyword
Bring an Item from an External Crate into Scope
Bring a Function in Scope Idiomatically
Bring a Struct or Enum in Scope Idiomatically
Reexport Items with pub use
Make use Declarations More Compact

Make your Code Items Public with the pub Keyword
Make your Code Items Accessible (Visibility Rules)
Make your Code Items Visible to your Library's Clients
Limit the Visibility of an Item to a Given Scope

Using a Dev Container Feature
Other Methods to Preview the Documentation HTML

Docker Compose
Deployment to GitHub Pages
Push Image to Docker Hub

Using VS Code
Other

Preprocessors Used in the Book
mdbook-scrub

Publication Steps

Folders and Key Files
Book Organization
Code Organization
All Examples are Fully and Continuously Tested

Attribute Syntax
Mark an Item as must_use
Mark an Item as deprecated
Control Compilation Diagnostic Messages with Lint Check Attributes
Suppress Irrelevant Warnings during Early Development
Enforce Good Practices and Catch Issues Early with Lint Attributes
Compile Code Conditionally with #[cfg(...)]
Conditionally Compile Code Blocks with cfg-if

Closure Syntax
Force Closure Capture by Value
Annotate Closure Types
Use Closures as Function Arguments

Declare Constants
Declare Statics

Execute Code based on a Condition Using if and else
Create Loops Using loop
Execute Code Repeatedly While a Condition is True with while
Iterate Through a Collection with for
Exit Early from Blocks

Use Scalar Data Types
Declare and Use Compound Data Types: Tuples and Arrays
Use the Unit and Never Special Types
Declare Strings
Declare a Type Alias

Define the Entry Point of your Application with the Main Function
Define the Entry Point of your Asynchronous Application

Enum Syntax
Common enums
Convert between Strings and Enum Variants with strum
Define Generic Enums

Write a Rust Function
Write a Generic Function
Return a Reference from a Function
Work with Diverging Functions
Work with Function Pointers

Const Generics
Use Lifetime Parameters
Use Type Parameters

Simplify Method Signatures with impl Trait
Return Opaque Types (esp. Closures and Iterators) with Return-position impl Trait

Iterator Trait
Use Iterators
Create Basic Iterators from Values and Closures
Use Iterator Adapters to Transform a Collection
Return an Iterator from a Function or Method
Accept Various Iterable Types as the Input of a Function or Method
Make a Collection Iterable by Implementing IntoIterator

Lifetime Basics
Use 'static as the Lifetime of the Running Program
Use Lifetime Parameters in Functions
Use Lifetimes and Lifetime Parameters in Struct Definitions and Implementations
Avoid Self-referential Structs
Lifetime Elision Rules

Common Macros from the Standard Library
Use Macros
Write Macros
Write Macros-by-Example
Create a Domain-Specific Language (DSL) with Macros
Write Procedural Macros
Derive Custom Traits with Procedural Macros
Create Custom Attributes with Procedural Macros
Create Function-like Procedural Macros
Avoid Common Pitfalls with Macros
Assert Conditions in your Tests with assert!, assert_eq!, and assert_ne!
Apply Attribute-like Macros
Conditionally Compile Code with cfg!
Concatenate String Literals with concat!
Derive Custom Traits with Procedural Macros
Report Errors From and Debug Macros
Use Function-like Macros
Understand the Hygiene of Macros-by-Example
Macros-by-Example
Capture the Arguments of a Macro-by-Example with Metavariables
Immediately Terminate the Current Thread with panic!
Print Messages to the Console with println! and friends
Use Repetitions in Macros-by-Example
Mark Sections of your Code as Unreachable or Unimplemented
Create a Vector with vec!

Use match to Branch on a Pattern
Handle a Single Pattern with if let
Loop as Long as a Pattern Matches with while let
Destructure Elements from an Iterator within a for Loop
Destructure during Assignment with let and let else
Destructure Arguments of a Function or Closure
Pattern Syntax
Match against Literals
Match against a Range
Bind to Variables
Destructure Structs
Destructure Enums
Destructure Tuples
Destructure References
Ignore Values
Use an Or (\|) to Match Multiple Patterns
Bind a Variable with @ Bindings (Bind to Subpatterns)
Match Guards (if condition)
Create References While Binding with ref and ref mut

Ownership
Move Semantics
Clone (Deep Copy)
Copy Semantics
References and Borrowing
Borrowing when Calling a Function

Install Rust and Create a First Project

Slice Basics
Create Slices from Arrays or Vectors
String Slices
Use a Slice as a Function Argument

Define and Create Structs
Declare Tuple Structs and Unit-like Structs
Design Structs for Ownership
Create an Instance of Struct from Another with the Struct Update Syntax
Implement and Use the Methods and Associated Functions of a Struct
Initialize Structs with a Constructor-like (Associated) Function
Define an Associated Constant for a Struct
Implement a Trait for a Struct
Implement Common Standard Library Traits
Define Generic Structs

Trait Objects Basics
Decide When to Use Trait Objects (and When Not To)
Dyn Compatibility / Object Safety
impl Trait vs dyn Trait
Trait Objects Can Have Only One Base Trait
Static Dispatch vs. Dynamic Dispatch

Trait Syntax
Provide a Default Implementation for a Trait's Function or Method
Define Associated Types in Traits
Define Associated Constants in Traits
Require that a Type Implement Other Traits (with Supertraits)
Implement a Local Trait for a Type Defined Elsewhere
Implement a Trait on a Type, Both Defined Elsewhere, with the "Newtype" Pattern
Prohibit Trait Implementation with the Sealed Trait Pattern
Provide a Blanket Implementation of a Trait
Define Generic Traits that Work with Multiple Types
Use a Trait Bound to Guarantee that a Generic Type Implements a Trait
Use Async with Traits

Immutability and Mutability
Shadowing
Destructuring

Chat Platforms, Forums, and Social Media
Rust Blogs and Newsletters
Personal Blogs
Project and Organization Blogs

Lists of Books
Essential and Official Books
Official Reference and Documentation
Free eBooks
Rust Books, General
APIs and Microservices
Async
Command Line Interfaces
Compiler and Tools
Concurrency and Parallelism
Data Analysis
Design Patterns
Embedded Systems
Error Handling
Foreign Function Interfaces (FFI)
Functional Programming
Idioms
Interpreters
Machine Learning
Macros
Network Programming
Performance
Random Numbers
Security
Standard Library
Unsafe Code
Web
Webassembly (WASM)

Companies that Use or Contribute to Rust
Rust Jobs

Lists of Popular Rust Repositories
Templates
Notable Repositories

Rust Overviews and Starting Points
Learning Roadmaps
Tutorials and Workshop Materials
Guides
Courses
University Courses
Ferrous Systems Training
Paid Courses
Others

Major Annual Conferences and Events
Prominent Local Meetups

Cheatsheets
Comparison to Other Languages

YouTube Channels, Videos
Rust Podcasts
Older Podcasts

Recipe	Crates
Accept Arguments of Multiple Types with AsRef
Use as_ref to Get a Reference to the Contained Value of a Smart Pointer
AsRef vs. Deref vs. Borrow

Recipe	Crates
Borrow Trait
Differences between Borrow, Deref, and AsRef in Generic Code
Implement Borrow for a Custom Type

Recipe	Crates
Store Data on the Heap with Box
Box Use Cases
Use Box to Store Dynamically Sized Types
Implement Recursive Data Structures with Box
Use Box as a Smart Pointer to Owned Trait Objects

Recipe	Crates
Test for Equality with PartialEq and Eq
Compare and Sort Values with PartialOrd and Ord

Recipe	Crates
Choose the Right Trait for a Conversion
Convert between Types with From

Recipe	Crates
Accept Either a Owned or Borrowed Value as the Input of a Function
Convert a Cow to a Borrowed or Owned Type
Efficiently Construct a Cow with into
Modify a Cow In-place
Return a Cow from a Function
Cow Alternatives

Recipe	Crates
Define Default Values for a Struct with Default

Recipe	Crates
Derive Common Traits Automatically
Derive Additional Traits with derive_more

Recipe	Crates
Release External Resources by Implementing the Drop Trait

Recipe	Crates
Determine the Type of an Object at Runtime and Downcast with the Any Trait

Recipe	Crates
Cell
RefCell
OnceCell

Recipe	Crates
Add Function-like Behavior to a Custom Type
Overload Operators like +, -, []

Recipe	Crates
Store Optional Values in Option
Use Adapters when Working with References
Extract the Value Contained in an Option with unwrap* and expect
Transform Values Contained Within an Option
Use Option with match, if let, or while let
Common Option Methods
Implement the "Early Return" Pattern with the ? Operator

Recipe	Crates
Give Data a Stable Memory Address with Pin
Related Data Structures

Recipe	Crates
Share Ownership of a Value with Rc
Share Ownership of a Value with Interior Mutability via Rc and RefCell
Share Ownership of a Value with Rc

Recipe	Crates
Handle Recoverable Errors with Result
Retrieve or Transform Values in Result
Get Reference to Values Inside a Result
Result vs Option

Recipe	Crates
Implement a Smart Pointer with Deref
Smart Pointer Comparison
Multiple Ownership with Reference Counting
Interior Mutability
Lazy Initialization
Synchronization Primitives