1. Introduction FREE CHAPTER

• Course Introduction
• Installing Rust and VS Code Editor
• Running and Compiling Your First Program

2. Basic Programming

• Program Outputs and Comments
• Variables and Scalar Data Types
• More on Variables – Shadowing, Constants
• Compound Data Types – Strings
• Compound Data Types – Tuples, Arrays
• Compound Data Types – Vectors
• Functions and Inputs

3. Ownership – The Heart of Rust Programming

• Ownership, Primitive, and Non-Primitive Types
• Application Memory – Heap and Stack
• Ownership and References in Functions
• Mutable and Immutable References
• Dereferencing

4. Control Structures

• Conditional If and Its Variants
• If Let and Nested If
• Match Statement
• While and Simple Loops
• For Loops and Their Variants
• Break and Continue

5. Project: Stack Implementation

• Implementing Stack
• String Reversal Using Stacks
• Expression Evaluation (Infix to Postfix Illustration)
• Expression Evaluation (Postfix Evaluation)
• Expression Evaluation – Part 1
• Expression Evaluation – Part 2
• Implementing Postfix Evaluation

6. Structures, Traits, Generics, Enums

• Structures Basics
• Traits and Default Implementations
• Functions within a Trait
• Enums
• Generics
• Option Enum
• Result Enum
• Hash Maps

7. Iterators, Lifetimes, and Closures

• Lifetimes – Part 1
• Lifetimes – Part 2
• Eliding Lifetimes
• Closures – Part 1
• Closures – Part 2
• Function Types
• Iterators – Part 1
• Iterators – Part 2

8. Rust Modules and Crates

• Rust Modules (Part 1)
• Rust Modules (Part 2)
• Cargo Tools to Visualize Module Hierarchy
• Re-Exporting Using Pub Use
• Using External Crates
• Publishing Your Crate

9. Smart Pointers

• Basics of Smart Pointers
• Box Smart Pointers and When to Use It
• Refining Cons List and Custom-Defined Smart Pointers
• Singly Linked List (Part 1)
• Singly Linked List (Part 2)
• Generics and Deref Coercion in Smart Pointers
• Rc Smart Pointer
• RefCell Smart Pointer
• Doubly Linked List (Part 1)
• Doubly Linked List (Part 2)
• Reference Cycles Creating Memory Leakage

10. Advanced Techniques

• Macros Basic
• Capturing Types
• Repeating Patterns
• Unit Type, Expression Versus Statements, and Partial Move
• As_Ref and Partial Move in Option
• Take and Swap for Avoiding Allocations
• Question Mark Operator
• Testing Your Code (Part 1)
• Testing Your Code (Part 2)
• Testing Your Code (Part 3)

11. Real-Life Applications and Problem-Solving Using Rust

• Search Results Using Word Groupings with HashMaps and Nested Loops
• Product Popularity Using HashMaps
• Highest Stock Price Using MaxStack and Structures
• Finding an Employee with No Meeting Using Multidimensional Arrays
• Longest Non-Stop Working Employee Using HashSets
• Items Suggestions Using HashSets and Vectors
• Items in Ranges Using Binary Search Tree (Part 1)
• Items in Ranges Using Binary Search Tree (Part 2)
• Fetching Top Products
• Effective Storage and Retrieval Using Trie Data Structure
• Most Recently Used Product Using Doubly Linked List and HashMaps (Part 1)
• Most Recently Used Product Using Doubly Linked List and HashMaps (Part 2)
• Displaying Participants in an Online Meeting (Part 1)
• Displaying Participants in an Online Meeting (Part 2)

12. Deep Dive Into Traits

• Trait Bounds
• Associated Types
• Trait Items
• Scope of a Trait, Marker, and Super Trait
• Some Useful Traits
• Static Versus Dynamic Dispatch (Trait Objects)

13. Efficient Programming with Rust

• Initializing Struct Instances
• Function Inputs and Coercion
• Iterating Through Option
• Disabling Mutability for Finalized Objects
• String Concatenation and Ownership
• Simplifying Structures
• Efficient Programming Tips
• String Literals
• Todo Macro and Some Useful Extensions
• The Builder Pattern

14. Concurrency

• Threads Basics
• Multiple Threads and Ownership in Threads
• Communication Through Channels
• Multiple Producers, Threads, and Functions
• Sharing States
• Passing Mutexes between Threads
• Synchronization Through Barriers
• Project: Web Scraping Using Threads
• Scoped Threads
• Thread Parking, Yielding
• Async Await
• Async Await (Tasks and Select)

15. Text Processing, File and Directory Handling

• Basic File Handling
• Directory and Path-Related Functions
• Regular Expressions Basics
• Repetitions Quantifiers and Capturing Groups

16. A Deeper Look at the Sized and Unsized Types in Rust

• Unsized Types and References to Them
• Possibly Sized Property
• Rust-Provided Non-Sized Types
• Coercion in Unsized Types

17. Error Handling

• Rust Error Handling
• Propagating Errors Finalized
• Multiple Error Types
• Chaining Question Mark
• Layered Outcomes Wrapping Results and Options in Rust (Part 1)
• Layered Outcomes Wrapping Results and Options in Rust (Part 2)
• Anyhow Crate
• Thiserror

18. Beyond Basic References

• Types of Reference
• Casting and Assignment of References
• Destructuring References
• Forcing Variables to Use References
• Referencing in Compound Data Types
• Pattern Matching Contexts
• Destructured Struct Parameters
• References Constraints in Method Chaining

19. Coercion in Rust

• Coercion Basics (Deref Coercion)
• Coercion Sites
• Reference Coercion
• Function Item Coercion
• Trait Objects Coercion
• Unsized Coercion
• Coercion in Generics
• Transitivity in Coercion
• Least Upper Bound Coercion

20. Beyond Simple Lifetimes

• References Recap (Part 1)
• References Recap (Part 2)
• Relating Lifetimes Using Bounds
• Relating Lifetimes – Implied Bounds
• Relating Lifetimes – Subtyping and Variance
• Relating Lifetimes – Contravariance
• Relating Lifetimes – Invariance (Part 1)
• Relating Lifetimes – Invariance (Part 2)

21. Traits

• Orphan Rule
• Trait Objects Limitations (Multiple Traits)
• Trait Objects Limitations (Associated Types)
• Trait Objects Limitations (Methods with Generics) Finalized
• Function with No Self Parameter Finalized
• Size and Trait Objects
• Partial Object Safety
• Operator Overloading Finalized
• Sealed Trait

22. Downcasting

• Downcasting Trait Objects
• Downcasting Usecase
• Downcasting for Conversion Between Trait Objects
• Checking Type without Downcasting Using TypeId

23. Dropcheck

• Drop Check
• Drop and Partial Move
• Drop Order (Part 1) Finalized
• Drop Order (Part 2)
• Drop Order and Self-Referential Types
• Avoiding Drop Finalized
• Panic Safety

24. Blockchain in Rust

• Blockchain Theory (Part 1: Hashes)
• Blockchain Theory (Part 2: Blocks and Blockchain)
• Blockchain in Rust (Part 1: Basic Structures and Functions)
• Blockchain in Rust (Part 2: Chain Validation and Selection)

25. Web Programming

• Web Programming Basics
• Making Responses
• Multiple Requests Using Threads

26. Measuring and Improving Performance

• Benchmarking Using Criterion
• Performance Lints