Rust Programming Bootcamp: From Beginner to Expert

Learn how to declare variables with let, apply type inference or explicit types, and manage immutability by default, while using mut and shadowing to change values, types, and scope.

Explore const and static in Rust, including compile-time evaluation and memory implications, with Rust vs C macro differences. Learn about block scope, static mut, and unsafe code.

Explore Rust basic data types across four categories—signed integers (I8–I128), unsigned integers (U8–U128), floating points (F32, F64), boolean, and char—plus platform-dependent sizes and type inference using I32 by default.

Explore the difference between tuples and arrays in Rust, compare composite vs collection types, and learn how vectors, strings, and hash maps fit into fixed-length versus dynamic data structures.

Explore Rust memory management by examining ownership, borrowing, and lifetimes, compare Rust with C/C++ and GC languages, and learn how the ownership model prevents memory errors.

Explore Rust's two string types—owned strings and string literals (&str)—and how ownership, lifetimes, and passing by value or reference affect usage and conversions.

Explore Rust enums as user-defined data types with variants and patterns, using match to handle results and options, embed types and generics for more readable, powerful code.

Explore Rust structures, define structs with fields, and distinguish methods from associated functions using self to manage ownership; apply to a beverage example with flavors and price.

Explore Rust's ownership rules, including single owner, scope-based drop, and moves. Learn immutable and mutable borrowing and how moves transfer ownership, plus how self-based methods relate to object-oriented concepts.

Master stack and heap concepts, including first in, last out behavior and known size requirements, and explore box pointers, ownership transfer, and copy and clone traits.

Learn flow control and functions in Rust, comparing if and match for pattern matching, with range and or patterns, and using match as an expression that returns values.

Master Rust loops and iteration by comparing loop types and break, continue, and labeled breaks, and explore iterators with next, map, and collect for expressive, zero-cost abstractions.

learn the basics of rust functions, including fn declarations, main as entry point, parameter types and return values; explore copy-by-value, move semantics, mut, and mutable borrowing.

Demonstrate how Rust handles function parameter passing by move with non-copy values, then illustrate immutable borrowing for read-only access and mutable borrowing for in-place modification, with ownership considerations.

Explore Rust's function return values and ownership, comparing copy and non-copy types, value versus reference returns, lifetime annotations, and the lifetime elision rule for safe, efficient code.

Explore higher order functions in Rust, using closures, map, filter, and fold (reduce) to transform collections, with emphasis on ownership, borrowing, and iterators.

Explore error handling in Rust by examining result, option, and panic, then unwrap and the question mark operator, and define a custom error type to manage recoverable and unrecoverable errors.

Explore Rust error handling with unwrap and the question mark operator; propagate errors in functions returning Result or Option, and see how iterators return Option.

Define a custom error type by creating a struct with details, implement the display trait, and implement the error trait. Learn to propagate errors between different error types in Rust.

Explore borrowing and lifetimes with the borrow checker, covering mutable and immutable references. Learn the four key rules, lifetime validity, and mutability exclusivity, plus automatic inference and manual lifetime annotations.

Explore lifetimes and functions in Rust, learning how the compiler infers lifetimes and prevents dangling references. Understand how input and output references relate through explicit annotations and lifetime rules.

Explore lifetimes and structs in Rust, learn when to annotate lifetimes, how borrowing and mutable references work, and best practices to avoid unnecessary annotations.

Explore generics in Rust chapter 7, focusing on generic structs and type parameters to reuse logic across different data types, with zero cost abstraction and traits.

Explore generic functions in Rust, applying type parameters to standalone functions and methods within generic types to swap values across data types and explore trait bounds for safety.

Explore Rust traits from basics to advanced: define trait signatures, implement default methods, use trait objects for polymorphism, compare trait objects, and implement operator overloading across types.

Discover trait objects and box in Rust, enabling collections of different types through a shared trait, via dynamic dispatch and heap allocation, with trade-offs in performance.

Explore trait objects and generics in Rust, showing how different types can implement the same trait and be used with generic parameters, and compare trait bounds and where clauses.

Learn to implement operator overloading in Rust by adding two points via the Add trait, define its Output, and print results with Display while exploring ownership and generics.

Explore polymorphism and inheritance in Rust through traits, noting that Rust is not object oriented and relies on composition, delegation, and functional programming for code reuse.

Demonstrate common Rust traits such as Clone, Copy, and PartialEq, showing how derive simplifies implementing them for structs and enums, including nested types like a race enum.

Explore iteration versus looping in Rust, contrast for loops with iterators, and learn how zero-cost abstractions boost readability and performance through examples like fold and iter.

Discover how IntoIterator converts a type into an iterator and transfers ownership. Examine how Iterator provides map and filter to traverse and transform collections with immutable or mutable borrows.

Explore three Rust iterator methods: iter, iter_mut, and into_iter, to convert collections, access elements immutably or mutably, and transfer ownership with practical ownership and lifetime considerations.

Explore implementing iter, iter_mut, and into_iter for a custom stack backed by a vector, demonstrating ownership and mutable references and slice conversions in Rust.

Explore basic concepts of closures in Rust, including capture by reference and by value, type inference, and practical use in sorting and functional style.

Learn how closures capture parameters in Rust: by reference (mutable or immutable borrowing) or by taking ownership with move semantics. The compiler auto-selects Fn, FnMut, or FnOnce based on usage.

Uncover how closures are compiled into objects: a struct with a call method that captures data. Learn how context selects Fn, FnMut, or FnOnce, and how move semantics affect ownership.

Explore practical examples of closure traits FnOnce, FnMut, and Fn as function parameters, and explain how mutable and immutable references and move semantics work in Rust.