Rust Programming

  1. Rust Fundamentals
    1. Variables and Mutability
      1. Variable Bindings with let
        1. Immutability by Default
          1. Mutable Variables with mut
            1. Variable Shadowing
              1. Scope and Lifetime Basics
                1. Constants with const
                  1. Static Variables with static
                    1. Naming Conventions
                    2. Scalar Data Types
                      1. Integer Types
                        1. Signed Integers
                          1. i8, i16, i32, i64, i128
                            1. isize Architecture-Dependent
                            2. Unsigned Integers
                              1. u8, u16, u32, u64, u128
                                1. usize Architecture-Dependent
                                2. Integer Literals
                                  1. Decimal Literals
                                    1. Hexadecimal Literals
                                      1. Octal Literals
                                        1. Binary Literals
                                          1. Byte Literals
                                          2. Type Suffixes
                                            1. Integer Overflow Behavior
                                              1. Debug Mode Panics
                                                1. Release Mode Wrapping
                                                  1. Explicit Overflow Methods
                                                2. Floating-Point Types
                                                  1. f32 Single Precision
                                                    1. f64 Double Precision
                                                      1. Floating-Point Literals
                                                        1. Scientific Notation
                                                          1. Precision and Rounding Considerations
                                                            1. Special Values
                                                              1. Infinity
                                                                1. NaN
                                                              2. Boolean Type
                                                                1. bool Type
                                                                  1. true and false Literals
                                                                    1. Boolean Operations
                                                                      1. Logical Operators
                                                                      2. Character Type
                                                                        1. char Type
                                                                          1. Unicode Scalar Values
                                                                            1. Character Literals
                                                                              1. Escape Sequences
                                                                                1. Unicode Escape Sequences
                                                                              2. Compound Data Types
                                                                                1. Tuples
                                                                                  1. Tuple Definition Syntax
                                                                                    1. Accessing Tuple Elements
                                                                                      1. Dot Notation
                                                                                        1. Pattern Matching
                                                                                        2. Destructuring Tuples
                                                                                          1. Unit Type
                                                                                            1. Tuple Type Annotations
                                                                                            2. Arrays
                                                                                              1. Array Definition Syntax
                                                                                                1. Fixed-Size Collections
                                                                                                  1. Array Type Annotations
                                                                                                    1. Accessing Array Elements
                                                                                                      1. Array Bounds Checking
                                                                                                        1. Array Initialization
                                                                                                          1. Explicit Values
                                                                                                            1. Repeated Values
                                                                                                            2. Iterating Over Arrays
                                                                                                          2. Functions
                                                                                                            1. Function Definition Syntax
                                                                                                              1. Function Naming Conventions
                                                                                                                1. Parameters and Arguments
                                                                                                                  1. Parameter Types
                                                                                                                    1. Multiple Parameters
                                                                                                                      1. Parameter Patterns
                                                                                                                      2. Function Bodies
                                                                                                                        1. Statements vs Expressions
                                                                                                                          1. Expression-Based Returns
                                                                                                                            1. Explicit Return Statement
                                                                                                                            2. Return Types
                                                                                                                              1. Unit Return Type
                                                                                                                                1. Explicit Return Types
                                                                                                                                  1. Type Inference
                                                                                                                                  2. Function Signatures
                                                                                                                                    1. Function Pointers
                                                                                                                                      1. Higher-Order Functions
                                                                                                                                      2. Comments and Documentation
                                                                                                                                        1. Line Comments
                                                                                                                                          1. Block Comments
                                                                                                                                            1. Documentation Comments
                                                                                                                                              1. Outer Doc Comments
                                                                                                                                                1. Inner Doc Comments
                                                                                                                                                2. Doc Comment Syntax
                                                                                                                                                  1. Markdown in Documentation
                                                                                                                                                    1. Code Examples in Documentation
                                                                                                                                                      1. Generating Documentation
                                                                                                                                                        1. Viewing Documentation Locally
                                                                                                                                                        2. Control Flow
                                                                                                                                                          1. Conditional Expressions
                                                                                                                                                            1. if Expressions
                                                                                                                                                              1. else if Expressions
                                                                                                                                                                1. else Expressions
                                                                                                                                                                  1. if as Expression
                                                                                                                                                                    1. Conditional Assignment
                                                                                                                                                                    2. Repetition and Loops
                                                                                                                                                                      1. loop Infinite Loops
                                                                                                                                                                        1. Breaking from Loops
                                                                                                                                                                          1. Continuing Loops
                                                                                                                                                                            1. Loop Labels
                                                                                                                                                                              1. Returning Values from Loops
                                                                                                                                                                              2. while Conditional Loops
                                                                                                                                                                                1. Condition Evaluation
                                                                                                                                                                                  1. Loop Variables
                                                                                                                                                                                  2. for Loops
                                                                                                                                                                                    1. Range Iteration
                                                                                                                                                                                      1. Collection Iteration
                                                                                                                                                                                        1. Iterator Patterns
                                                                                                                                                                                      2. Pattern Matching in Control Flow
                                                                                                                                                                                        1. Basic Pattern Matching
                                                                                                                                                                                          1. Destructuring Patterns
                                                                                                                                                                                            1. Guard Conditions

                                                                                                                                                                                        Previous

                                                                                                                                                                                        1. Getting Started with Rust

                                                                                                                                                                                        Go to top

                                                                                                                                                                                        Next

                                                                                                                                                                                        3. Understanding Ownership