Rust Programming Language: The Complete Course

Declare and manipulate variables using the let keyword, explore data types, and print results with placeholders in rust, through a hands-on demo and a small project.

Explore Rust data types, including scalar and compound types, and learn how type inference works and when explicit annotations are required, with practical examples.

Explore floating-point data types in Rust, comparing 32-bit and 64-bit representations, and learn how numeric literals default to 64-bit unless explicitly annotated with 32-bit.

Explore booleans, the true or false values behind Rust conditional expressions. See how a score like more than 90 drives if statements and boolean decisions.

Explore how Rust represents characters as Unicode values beyond single bytes, including emojis. Learn to write and print characters using single quotes, and see cargo run in Visual Studio Code.

Explore tuples and arrays as compound data types in Rust, learn to store multiple values, access elements by index, and understand arrays on the stack with safety against out-of-bounds access.

Define and call functions to avoid repeating code, organize your Rust programs into modular blocks, and use snake_case for naming; learn parameter passing, arguments, and returning values from functions.

Explore how statements and expressions differ in Rust, and how a function returns a value through the final expression or an explicit return, with examples of assignments and semicolon effects.

Explore control flow with if and else, including else if and loops, to execute code based on conditions. Learn expressions versus statements and how assignment and types affect outcomes.

Explore Rust control flow with while and for loops, using break and conditions to avoid infinite loops, increment counters, and repeat tasks until a condition turns false.

Explore Rust ownership rules that govern memory, compare stack and heap, and show automatic drop at scope end to ensure memory safety without garbage collection.

Explore how Rust's ownership model manages memory for strings, including heap allocation, move semantics, and clone for deep copies.

Explore Rust's ownership model and how heap and stack memory are managed. See how clone and copy enable multiple values while drop trait handles cleanup.

Explore Rust's ownership model by examining mutable and immutable references, how borrowing prevents data races, and the rules around multiple mutable references and scope-based access to strings.

Explore Rust structs as named, customizable data types that bundle related values, create instances with named fields, and access data with dot notation.

Explore initializing Rust structs with field init shorthand, passing values for selected fields, using shorthand when variable names match, and building reusable struct instances efficiently.

Learn to initialize a new struct from an existing one with the struct update syntax in Rust. Reuse name and email from another instance to update fields.

Tuple structs in Rust offer unnamed fields for grouping values, instantiated as Point(1, 2, 3) and accessed via p.0, p.1, p.2. Different tuple struct types remain not interchangeable.

Explore rust enums, including wrapping named constants and seven day values, with pattern matching and idioms; define structs, access enum variants, and derive debug to print.

This lecture demonstrates using the Rust match statement to exhaustively compare enum values (small, medium, large), print results, and use an underscore placeholder for unlisted cases.

Learn to handle recoverable errors with the result enum, using Ok and Err variants and match to extract values or report failure. Avoid panics by handling missing files and permissions.

Learn how unwrap and expect streamline error handling in Rust by extracting values from Result and triggering panics with customizable messages, improving debugging and code clarity.

Explore generics in Rust, learning how generic types let you write concise, safe code across structs, functions, methods, enums, and collections using angle-bracket syntax, with compiler errors for mismatched types.

Define a generic struct in Rust with a generic type parameter to store a single type across fields, demonstrated by a 2d point with x and y.

Learn to define generic functions that work across multiple types, reducing duplication by using a single signature with a generic type parameter and Ord bounds for max comparisons.

Define a trait in Rust by declaring method signatures and optional concrete methods, implement the trait for structures, and override abstract methods as needed.

Learn to define and implement traits for Rust structs, implement a speak method for dog and cat, use default trait methods, and call trait implementations on instances.

Explore the Rust standard library's input/output features, focusing on the Read and Write traits, byte-oriented input, and examples of readers and writers.

Explore how Rust's read trait enables reading input from keyboards or files using the read_line method into a mutable string, showing standard input and bytes read.

Learn the write trait for writers in Rust, using write to output bytes to a stream and return a result, with a stdout example showing bytes written and error handling.

Discover file I/O with the file struct in Rust, covering open, read-only mode, and overwrite behavior, then learn to remove, append, write, and read to string.

Learn how to read from a file in Rust by opening an existing file, reading its contents into a mutable string, and printing the results.

Explore the OpenOptions struct and configure file access in Rust using read, write, create, and append options. Learn how to open files with combined settings and common aliases.

Explore the iterator trait in Rust, defining methods like item and next, using Option with Some and None to traverse collections, printing elements in order.

Explore three methods to obtain an iterator over a Rust collection: iter borrows elements as references, into_iter consumes the collection, and iter_mut yields mutable references to modify elements.

Explore defining and using closures in Rust, including anonymous functions assigned to variables, capturing outer scope, and invoking with one or more parameters.