Rust Fundamentals Course

Getting Started with Rust

This chapter introduces Rust — what it is, why it was created, and what problems it solves. It covers the core promises of the language (memory safety without a garbage collector, zero-cost abstractions, and fearless concurrency) and walks through the Cargo build system and the structure of a basic Rust project.

Variables, Types, and Functions in Rust

This chapter covers the building blocks of any Rust program: declaring variables with `let` and `let mut`, Rust's scalar and compound data types (integers, floats, booleans, chars, tuples, and arrays), and defining functions with typed parameters and explicit return values.

Memory Without a Garbage Collector

This chapter explains Rust's ownership system — the feature that sets it apart from every other language. It covers the three ownership rules, what happens when values are moved or copied, and how references and borrowing let you use data without taking ownership of it.

Structs, Enums, and impl Blocks

This chapter covers structs and enums, Rust's primary tools for creating custom data types. It explains how to define and instantiate structs, attach methods using `impl` blocks, and use enums to represent values that can be one of several distinct variants — including the built-in `Option` enum.

Pattern Matching in Rust

This chapter explores Rust's powerful pattern matching system, focusing on the `match` expression, which exhaustively checks every possible variant of an enum or value. It also covers `if let` and `while let` as concise alternatives when only one pattern is relevant.

Errors: Result, Panic, and the ? Operator

This chapter covers Rust's approach to error handling, which avoids exceptions entirely in favor of explicit return types. It explains the difference between recoverable errors (represented with `Result<T, E>`) and unrecoverable errors (`panic!`), and shows how the `?` operator propagates errors cleanly through a call chain.

Vec, HashMap, and the String Types

This chapter introduces Rust's most commonly used collection types from the standard library: `Vec<T>` for growable sequences, `HashMap<K, V>` for key-value storage, and `String` for owned, heap-allocated text. It also clarifies the important distinction between `String` and `&str`.

Traits and Generics

This chapter introduces traits — Rust's mechanism for defining shared behavior across types, similar to interfaces in other languages — and generics, which allow functions and structs to work with any type that satisfies a set of trait bounds. Together, they are the foundation of reusable, type-safe Rust code.

Iterators and Closures in Rust

This chapter covers closures — anonymous functions that can capture values from their surrounding scope — and Rust's iterator model, which provides a rich set of composable adapters like `map`, `filter`, `fold`, and `collect` for processing sequences lazily and expressively.

Organizing a Rust Project

This chapter explains how Rust organizes code through its module system, covering the `mod` keyword, visibility with `pub`, and the `use` keyword for bringing items into scope. It also dives deeper into Cargo — Rust's build tool and package manager — including how to manage dependencies, use external crates from crates.io, and structure a multi-file project.

Summary

Final Rust Assessment

The final assessment tests your understanding of all topics covered in the Rust Fundamentals course, including ownership and borrowing, structs, enums, pattern matching, error handling, traits, generics, and iterators.