Rust Programming

  1. Advanced Features
    1. Unsafe Rust
      1. Unsafe Superpowers
        1. Raw Pointer Dereferencing
          1. Unsafe Function Calls
            1. Mutable Static Access
              1. Unsafe Trait Implementation
              2. Raw Pointers
                1. *const T and *mut T
                  1. Creating Raw Pointers
                    1. Pointer Arithmetic
                    2. Unsafe Functions and Methods
                      1. unsafe fn Syntax
                        1. Calling Unsafe Code
                          1. Safe Abstractions
                          2. Safety Invariants
                            1. When to Use Unsafe
                            2. Advanced Traits
                              1. Associated Types
                                1. Associated Type Syntax
                                  1. Associated vs Generic Types
                                  2. Default Generic Type Parameters
                                    1. Operator Overloading
                                      1. Operator Traits
                                        1. Custom Operator Implementation
                                        2. Fully Qualified Syntax
                                          1. Disambiguation
                                            1. Explicit Method Calls
                                            2. Supertraits
                                              1. Trait Dependencies
                                                1. Trait Bounds on Traits
                                                2. Newtype Pattern
                                                  1. Type Safety
                                                    1. Trait Implementation
                                                  2. Advanced Types
                                                    1. Type Aliases
                                                      1. Type Alias Syntax
                                                        1. Generic Type Aliases
                                                        2. Never Type
                                                          1. ! Type
                                                            1. Diverging Functions
                                                              1. Never Type Coercion
                                                              2. Dynamically Sized Types
                                                                1. DST Characteristics
                                                                  1. Sized Trait
                                                                    1. ?Sized Bound
                                                                    2. Function Item Types
                                                                      1. Closure Types
                                                                      2. Advanced Functions and Closures
                                                                        1. Function Pointers
                                                                          1. fn Type
                                                                            1. Function Pointer vs Closures
                                                                            2. Returning Closures
                                                                              1. Box<dyn Fn()> Pattern
                                                                                1. impl Fn() Pattern
                                                                                2. Higher-Order Functions
                                                                                  1. Function Traits Hierarchy
                                                                                  2. Macros
                                                                                    1. Declarative Macros
                                                                                      1. macro_rules! Syntax
                                                                                        1. Pattern Matching
                                                                                          1. Repetition Patterns
                                                                                            1. Macro Hygiene
                                                                                            2. Procedural Macros
                                                                                              1. Derive Macros
                                                                                                1. Attribute Macros
                                                                                                  1. Function-like Macros
                                                                                                    1. TokenStream Processing
                                                                                                    2. Macro Development
                                                                                                      1. Debugging Macros
                                                                                                        1. Macro Testing
                                                                                                          1. Macro Documentation

                                                                                                      Previous

                                                                                                      13. Fearless Concurrency

                                                                                                      Go to top

                                                                                                      Next

                                                                                                      15. Foreign Function Interface