🧵 Quick Tour

1. Rust’s Variables.

   • Rust’s variable declaration is powerful and supports type inference (in case you didn’t explicitly mention it) for mutable and immutable bindings.

    let mut var_name: f64 = 69.69;
   

   

2. Rust Constants.

   • Constants in Rust are a great way to define values that cannot be altered, providing both performance benefits and compile-time safety.

    const SCREEN_WIDTH: i32 = 69;
   

   

3. Rust’s Functions.

   • Rust’s functions are expressive and flexible, with support for return values, parameters, and closures.

   

4. If statements.

   • If statements in Rust are concise and readable, with support for both simple and complex conditions.

   

5. Rust Enums.

   • Enums in Rust are a powerful way to define a set of related values, with support for associated data and pattern matching.

   

6. Rust Generics.

   • Rust’s generics provide a powerful way to write reusable code, with support for constraints and default types.

   

7. Optional Enums.

   • Optional enums in Rust provide a powerful way to handle optional values, with support for pattern matching and fallback values.

   

8. Ownership in Rust.

   • Ownership in Rust provides a unique way to manage memory, ensuring that only one owner can modify a value at any given time.

   

9. Rust Borrowing.

   • Borrowing in Rust provides a safe way to allow multiple references to a value, without allowing mutation or invalidation.

   

10. Rust Lifetimes.

    • Lifetimes in Rust provides a way to manage the lifetime of references, ensuring that they are valid for as long as they are needed.

    

You can refer to this twitter thread for more info.