Docker Compose
Deployment to GitHub Pages
Push Image to Docker Hub

Using VS Code
Other
Alternative just Install
Alternative mdbook Install

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

Preprocessors Used in the Book
mdbook-scrub, a Custom Preprocessor for mdbook

Steps to Publish to crates.io

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

Recipe	Crates	Categories
Calculate the SHA-256 Digest of a File
Hash with sha2
Hash with sha1
Hash with md-5
Hash with blake3
Cryptograhic Algorithms
foldhash
Legacy Hashing Algorithms
Use General-purpose Hashing Algorithms

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
Generate Random Numbers with fastrand

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

Recipe	Crates	Categories
Create a Map Sorted by Key with BTreeMap
Create a Sorted Set with BTreeSet<T>

Recipe	Crates	Categories
Implement a Priority Queue with priority-queue
Implement a Priority Queue with priority-queue

Recipe	Crates	Categories
Work with C-style Flags using bitflags
Work with C-style Flags using flagset
Create and Manipulate Bit Vectors with bitvec
Store Large Sets of Integers with roaring

Recipe	Crates	Categories
Create and 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
Work with Heapless Data Structures with heapless

Recipe	Crates	Categories
Store Data in a Linked List

Recipe	Crates	Categories
Store Data in an Insertion-ordered Map
Store Multiple Values for a Single Key with multimap
Store Collections of Objects that Need Unique, Stable, Safe Identifiers

Recipe	Crates	Categories
Store Fixed-size Vectors and Strings on the Stack with arrayvec
Store Small Vectors on the Stack with Fallback to the Heap, with smallvec
Store Small Vectors on the Stack with Fallback to the Heap, with 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
Generate and Parse ULIDs

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

Recipe	Crates	Categories
Get the Current Working Directory
Create, List Contents of, and Remove Directories
Remove a Directory and its Contents with 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
Display File Metadata

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

Recipe	Crates	Categories
Canonicalize a Path
Ensure your Paths are UTF-8 with camino
Create and Manipulate Paths

Recipe	Crates	Categories
Read from and Write to a File
Avoid Writing and Reading from the Same File
Access a File Randomly Using a Memory Map

Recipe	Crates	Categories
Work with Symbolic Links

Recipe	Crates	Categories
Create Temporary Files or Temporary Directories

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

Recipe	Crates	Categories
Read from the Standard Input and Write to the Standard Output or Standard Error

Recipe	Crates	Categories
Abstract over Different Number Types
Use Big Integers
Use Big Decimals
Sort Floats
Use Big Integers with num-bigint
num
Work with Arbitrary-precision Integers, Rationals, Floats, and Complex Numbers with 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

How to Use the Code Examples
Additional Examples
A Note about Crate Representation
A Note about Error Handling

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
Generics Syntax

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
Use Lifetime Parameters

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!

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

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
Destructure

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

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 Object Restrictions

Declare a Trait
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
Declare a Trait

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
Other 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 Programming
Webassembly (WASM)
Rust Books, by Topic

Lists of Popular Rust Repositories
Templates
Notable Rust Code Repositories
Build Your Own X
ChromeOS Virtual Machine Monitor
Small Examples and Exercises
"RealWorld" Examples
Source Code for Rust Books

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

Major Annual Conferences and Events
Prominent Local Meetups

Cheatsheets
Comparison to Other Languages

Companies that Use or Contribute to Rust
Rust Jobs

YouTube Channels, Videos
Rust Podcasts
Older Podcasts

Recipe	Crates
Derive Common Traits Automatically
Derive Additional Traits with derive_more

Recipe	Crates
Use the Borrow Trait to Work with Borrowed Types Synonymous with Owned Types
Differences between Borrow, Deref, and AsRef in Generic Code
Implement Borrow for a Custom Type

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
Use Arc, Rc, Box as Cow Alternatives
Clone Data Lazily with Cow

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

Recipe	Crates
Define Default Values for a Struct with Default

Recipe	Crates
Determine the Type of an Object at Runtime and Downcast with the Any Trait
Compile-time Reflection

Recipe	Crates
Store Data on the Heap with Box
Decide When to Use Box
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
Use Cell
Use RefCell
Use OnceCell

Recipe	Crates
Give Data a Stable Memory Address with Pin

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
Work with the Contents of an Option
Implement the "Early Return" Pattern with the ? Operator

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

Recipe	Crates
Accept Arguments of Multiple Types with AsRef
Use as_ref to Get a Reference to the Contained Value of a Smart Pointer
Choose between AsRef, Deref, and Borrow

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
Release External Resources by Implementing the Drop Trait

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

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