Rust Fundamentals

Create a function that prints 'Hello, world!' to the console using Rust.

Learn to declare immutable variables in Rust and understand their usage.

Define and modify mutable variables in Rust.

Learn how to define and use constants in Rust.

Get familiar with primitive data types in Rust by defining and annotating variables.

Implement a function to convert numerical types using the `as` keyword in Rust.

Practice mathematical operations in Rust, including addition, subtraction, multiplication, and division.

Calculate the sum of all elements in an array.

Create a function that returns a tuple of values.

Understand and use the unit type `()` in Rust.

Implement and work with functions in Rust.

Implement basic control flow in Rust using if-else statements.

Understand and implement Rust's ownership model.

Implement Rust's ownership model with mutable references.

Identify and fix ownership rule violations in Rust code.

Write a program that takes a string as input and counts the number of characters in the string.

Find the largest element in a slice of integers.

Manipulate elements in a mutable slice in-place using iteration.

Practice updating specific elements of a mutable slice in Rust.

Learn how to define and use structs in Rust.

Learn to define and use tuple structs in Rust.

Learn to create constructors for Rust structs.

Learn about unit structs and their use cases in Rust.

Learn how to define and use methods on Rust structs.

Create a program that manages a registry of animals in a sanctuary.

Learn to use Rust's `derive` attribute to implement the `Debug` trait for custom structs.

Learn how to use enums in Rust by implementing a basic TrafficLight enum.

Learn how to use enums with unit and tuple variants by implementing a Card enum.

Explore complex enums by combining unit, tuple, and named field variants in Rust.

Learn how to define and use methods on Rust enums.

Learn how to use the derive macro to implement PartialEq for an enum.

Practice pattern matching on enums using `if let`.

Perform basic operations on vectors in Rust.

Use Rust's HashMap to create a simple key-value store.

Manage student grades using structs and hashmaps without error handling.

Extend the student grades system with methods inside the Student struct.

Implement functions that work with optional values using Option<T>.

Implement graceful error handling in Rust using the Result type.

Enhance error handling by defining custom error types and implementing the `Error` trait.

Learn how to propagate errors while reading integers from a file in Rust.

Learn how to propagate `Option` values in a clean and idiomatic way.

Learn how to handle `Result` from an I/O operation and convert it to `Option`.

Learn how to convert an `Option<T>` to a `Result<T, E>` in Rust.

Learn to handle unrecoverable errors in Rust using `panic!`.

Learn to handle unrecoverable errors in Rust using `unwrap` and `expect` with function calls.

Implement and use traits to define shared behavior in Rust.

Use generics with traits to create reusable and flexible code.

Use trait bounds to constrain generic types in Rust.

Implement a function that uses the AsRef trait to work seamlessly with borrowed string types.

Implement the From trait for a custom type.

Use `impl Trait` syntax to return an iterator that filters strings starting with a keyword.

Learn to create and return trait objects in Rust using Box<dyn Trait>.

Learn how to use trait objects as fields in structs for dynamic behavior in Rust.

Implement a trait with associated types in Rust.

Implement a trait that requires another trait in Rust.

Design a plugin system using Rust's trait objects.

Understand and implement lifetimes in Rust to ensure memory safety.

Create a struct that holds a reference and performs keyword searches in a string slice.

Implement a struct that holds a mutable reference to a String and modifies its content.

Learn how to define and use closures in Rust.

Understand and define closure types in Rust with practical examples.

Learn to work with Rust iterators by implementing filtering and transformation operations.

Use Rust iterators to filter and collect unique items from a collection.

Understand and use Box<T> to allocate values on the heap.

Implement custom behavior for a struct when it goes out of scope using the Drop trait.

Explore reference-counted smart pointers in Rust using Rc<T> to share data.

Understand and utilize interior mutability in Rust using Rc and RefCell.

Use threads to mutate a shared vector with non-deterministic ordering.

Learn how to communicate between threads using Rust's mpsc channels.

Implement and manage shared state in concurrent programming using threads and Mutex in Rust.

Utilize Rust's advanced pattern matching capabilities to destructure complex data.

Implement and use advanced trait functionalities in Rust.

Create a basic macro in Rust to demonstrate its functionality.

Create a macro to implement a trait for generating default values for various types.

Implement and use the Default trait for custom types in Rust.

Implement a simple procedural macro to automatically derive a custom trait.