Rust lang: The complete beginner's guide

Install Rust and set up your environment, then build a hello world project. Use Cargo to create, run, and document projects, handle user input, and print to the console.

Install rust on mac or pc by visiting rust-lang.org, following the get started steps, and verifying the installation with rustc and cargo.

Discover how the Rust package manager cargo powers creating projects, building and running code, cleaning artifacts, and generating documentation, with development environment workflows and optional command-line usage.

Learn how to read user input in Rust with std::io and read_line, using a mutable string, printing results, and handling errors via match, while exploring references, pointers, and macros.

Learn how Rust uses line and multi-line comments and doc comments to generate documentation for crates, modules, and functions using cargo doc, with headings and code blocks.

Master printing values to the console in Rust with print line and formatting, including variables, expressions, positional and named arguments, and the debug trait for complex data.

Explore Rust basics by learning how variables work, the available data types, and how strings differ. Discover constants, operators, and a preliminary introduction to functions used throughout the course.

Explore Rust variables: declare with let, infer types or specify i32 and i64; embrace immutability by default, use mut for changes, and master shadowing, snake_case naming, and multiple assignments.

Explore Rust scalar data types, including integer sizes and the default type, floats, booleans, and characters, and learn typecasting, number separators, and unicode usage.

Explore Rust strings and string slices, including the scalar type str, static lifetimes, and the difference between immutable slices and mutable String objects, with len, push, push_str, and replace.

Discover Rust constants that cannot be changed, require an explicit type, follow uppercase convention, disallow shadowing, and can be global or local in scope, as demonstrated with a URL constant.

Explore Rust operators, including arithmetic (addition, subtraction, multiplication, division, modulus), relational, logical, and bitwise operations, with practical examples. Note that increment and decrement are not supported in Rust.

Explore how to define and call functions in Rust, pass parameters by value or by reference (borrowing), and return results, while seeing practical examples of printing and formatting strings.

Explore how to create modules and crates in Rust to split functionality into logical components and reuse components built by other developers in your project.

Explore Rust modules, organizing code into files and modules, using pub visibility, mod declarations, and nested modules to structure functionality.

Explore crates as an abstraction over modules, creating binary and library crates with cargo, and integrate local or external crates via dependencies to archive files and generate random numbers.

Generate random data in Rust using the Rand crate, including integers and floats. Create bounded values with gen_range and craft a 30-character alphanumeric string using thread_rng and distributions.

Explore Rust data types, including arrays, vectors, slices, tuples, structures, enums, and generics. Learn how each construct behaves and when to use them in real code.

Explore arrays in Rust: fixed-size collections of the same type, how to define, index, mutate elements, print with debug, use defaults and constants, and iterate with a for loop.

Learn how to use vectors in Rust, created with Vec::new or vec!, mutated with push and remove, initialized with defaults via vec![value; n], and iterated with numbers.iter().

Explore how slices in Rust function as pointers to parts of arrays or vectors, support runtime-sized views, enable indexed access, and allow mutable updates to elements and strings.

Explore Rust tuples as heterogeneous, fixed-size collections defined with parentheses, limited to 12 elements, accessed by dot indices, and destructured for clean variable binding, while learning mutability.

Define structures with the struct keyword, instantiate an employee with name, company, and age, enable printing via derive(Debug), and add methods with impl, including a static details function.

Define and use Rust enums, decorate them with debug, and print colors like red, green, blue. Extend enums with data, such as a person with name, surname, and age.

Discover how generics let you store different types in structs or enums in Rust, use single and multiple type parameters, and print results with debug formatting.

Explore control structures in Rust, including if statements, match statements, pattern matching, and the for and while loops, with practical examples.

Master the Rust if statement, evaluate conditions, use else and else if branches, and return results from branches, with practical examples and a random number.

Learn how Rust's match statement operates by matching an expression against multiple arms, including enums like suit and range patterns, returning a result with default handling.

Explore Rust pattern matching with the match statement, including or values, ranges, if guards, and tuple matching for oranges and coordinate points.

Explore Rust's for loop with ranges and collections, printing squares, using continue and break, iterating over pets, and using enumerate to access position and element.

Explore the while loop in Rust, showing condition-driven iterations, an infinite loop variant with break, and practical examples that print squares and cubes below a limit.

Review function basics and recap prior concepts, then explore scope in relation to functions. Dive into closures, higher-order functions, and macros, including creating macros that write code.

Learn how rust functions are created and called, with parameters by value or by reference and return values. Understand how scope deallocates variables, preventing memory leaks.

Apply higher order functions in rust by passing functions as parameters and using closures to map, take_while, filter, and fold to the sum of even squares below a limit.

Explore how Rust macros enable metaprogramming by writing code that expands during compilation, using macro_rules, exclamation-mark invocation, and varying parameters, expressions, and identifiers.

Discover how Rust traits work as interfaces for structures, enable generics, support dyn dynamic types, and empower operator overloading with static and dynamic dispatch.

Explains traits in Rust as interfaces with optional default implementations, how to implement them for Rust dev and Java dev, including required and static methods, and hello world examples.

Explore how trait generics and traits constrain types, implement a bark trait for a dog, and see why a cat cannot be passed to a generic function.

Explore returning a trait from a function in Rust by using box and dyn to create a trait object, enabling dog and cat implementations.

Learn to add traits to existing structures by implementing a Summable trait for a vector of i32, enabling a custom sum function and demonstrating basic usage.

Explore operator overloading by implementing the add trait for a custom point structure with x and y coordinates, using the use keyword, and printing results with a debug formatter.

Explore static dispatch and monomorphism in rust by implementing a duplicatable trait for strings and integers, and see how compile-time specialization optimizes memory and calls.

Learn how dynamic dispatch in Rust resolves trait method calls at runtime, contrasting it with static dispatch, and see how using a dyn trait object simplifies code while preserving output.

Explore memory management in Rust by examining ownership, borrowing, and lifetimes, and learn how reference counted variables simplify passing references in code.

Explore Rust ownership: one owner per piece of data, primitive types copy, complex types move and transfer ownership, and closures and vectors illustrate returns.

Learn how borrowing temporarily transfers ownership via references, using immutable and mutable borrows with dereferencing. See why mutating a borrowed value is disallowed to preserve memory safety.

Explore Rust lifetimes from static lifetime to lifetime parameters, and see how references between owners and dogs require lifetime specs; learn how lifetime elision handles implicit lifetimes.

Learn how to share data safely with reference counted variables using Rust's Rc, cloning references, and tracking strong_count to manage ownership and borrowing across scopes.

Master Rust error handling by working with files—opening, reading, writing, and closing—then explore errors, helper methods, and the question mark operator.

Master file operations in Rust by creating, writing, appending, reading, and deleting files with the standard fs library, using expect for error messages and open options for append.

Rust distinguishes unrecoverable panics from recoverable errors, using the panic macro, the Result enum, and the options enum to either crash or continue after handling errors.

Explore unwrap and expect as Rust error-handling helpers that either yield data or panic, replacing match statements with concise shortcuts and offering a custom error message option when needed.

Learn how the question mark operator propagates errors to simplify Rust code, replacing match statements when reading a username from a file, and contrasting it with unwrap.