Rust Language

This section is designed to provide a quick reference for Rust's language features, syntax, and best practices.

It is not intended to be a beginner's book nor a comprehensive guide, but rather a tool for those who are looking to refresh their knowledge. The Rust book↗ is an excellent resource for complete beginners to get started with. Refer as well to the books chapter for a list of relevant books.

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

Data Types
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

Variables
Immutability and Mutability
Shadowing
Destructuring

Constants and Statics
Declare Constants
Declare Statics

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

Lifetimes
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

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

Control Flow
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

Pattern Matching
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

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

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

Structs
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

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

Traits
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

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

Trait Objects and Dynamic Dispatch
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

Iterators
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

Generics
Const Generics
Use Lifetime Parameters
Use Type Parameters
Generics Syntax

Attributes
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

Macros
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!