A collection of small exercises to get you familiar with reading and writing Rust code. This is the completed solutions version where all 94 exercises have been solved.

Overview
Exercise Categories
Installation & Setup
Running Exercises
Project Structure
Exercise Completion Status
Learning Path
Resources

Overview

Rustlings is a collection of small, bite-sized exercises designed to teach you the fundamentals of Rust. Each exercise focuses on a specific concept and provides a hands-on learning experience. This repository contains all 94 exercises fully solved, organized into 24 different topics.

The course progresses from the absolute basics (variables, functions) through intermediate concepts (ownership, traits, lifetimes) to advanced topics (smart pointers, macros, error handling).

Exercise Categories

Core Fundamentals (27 exercises)

Topic	Exercises	Concepts
00_intro	2	Basic syntax, println! macro
01_variables	6	Variable declaration, mutability, shadowing, const
02_functions	5	Function definitions, parameters, return types
03_if	3	Conditional logic, if-else expressions
04_primitive_types	6	Booleans, characters, arrays, slices, tuples

Collections & Ownership (12 exercises)

Topic	Exercises	Concepts
05_vecs	2	Vector creation, iteration, modification
06_move_semantics	5	Ownership, borrowing, references
07_structs	3	Struct definition, initialization, methods
08_enums	3	Enum variants, pattern matching

Strings & Collections (10 exercises)

Topic	Exercises	Concepts
09_strings	4	String types, conversion, manipulation
10_modules	3	Module system, visibility, imports
11_hashmaps	3	HashMap operations, entry API

Type System & Traits (16 exercises)

Topic	Exercises	Concepts
12_options	3	Option type, pattern matching
13_error_handling	6	Result type, error propagation, ? operator
14_generics	2	Generic type parameters
15_traits	5	Trait definition, implementation, objects

Advanced Concepts (22 exercises)

Topic	Exercises	Concepts
16_lifetimes	3	Lifetime annotations, scope
17_tests	3	Writing and running tests
18_iterators	5	Iterator trait, adapters, consumers
19_smart_pointers	4	Box, Rc, Arc, Cow smart pointers
20_threads	3	Thread spawning, synchronization, channels
21_macros	4	Macro definition, visibility
22_clippy	3	Code linting, clippy recommendations

Conversions & Quizzes (8 exercises)

Topic	Exercises	Concepts
23_conversions	5	From/Into, TryFrom, FromStr, AsRef/AsMut
quizzes	3	Comprehensive knowledge checks

Installation & Setup

Requirements

Rust 1.56+ (Latest stable recommended)
Cargo (comes with Rust)

Getting Started

Clone or extract the repository
```
cd rustlings
```
Verify Rust installation
```
rustc --version
cargo --version
```
Check the Cargo configuration
```
cat Cargo.toml
```

Running Exercises

Running All Tests

To verify all solutions are correct:

cargo test

Running Specific Exercise Tests

To test a specific topic:

# Test a specific category
cargo test --test 01_variables

# Test a specific exercise
cargo test variables1

Viewing Exercise Details

Each exercise directory contains:

Individual .rs files with code
README.md with instructions and hints
Tests in the code to verify correctness

# View exercise instructions
cat exercises/01_variables/README.md

# Check a specific exercise file
cat exercises/01_variables/variables1.rs

Project Structure

rustlings/
├── Cargo.toml                 # Project manifest
├── rust-analyzer.toml         # Rust analyzer configuration
├── README.md                  # This file
├── exercises/                 # All exercise files
│   ├── 00_intro/             # Introduction exercises
│   ├── 01_variables/         # Variable exercises
│   ├── 02_functions/         # Function exercises
│   ├── ...
│   ├── 22_clippy/            # Code linting exercises
│   ├── 23_conversions/       # Type conversion exercises
│   └── quizzes/              # Comprehensive quizzes
├── solutions/                 # Reference solutions
│   ├── 00_intro/
│   ├── 01_variables/
│   └── ...
└── target/                   # Compiled artifacts (auto-generated)

Exercise File Format

Each exercise file typically contains:

// Description of what to learn
// TODO: instructions for what to implement

fn main() {
    // Your code here
}

#[cfg(test)]
mod tests {
    // Tests that verify your solution
}

Exercise Completion Status

Summary

Total Exercises: 94
Status: ✅ All 100% Complete

Learning Path

Recommended Order

Phase 1: Foundations (Days 1-2)

00_intro - Learn basic syntax
01_variables - Understand variable binding
02_functions - Write functions
03_if - Control flow
04_primitive_types - Data types

Phase 2: Collections & Ownership (Days 3-4) 6. 05_vecs - Collections 7. 06_move_semantics - Rust's unique ownership system 8. 07_structs - Custom types 9. 08_enums - Sum types

Phase 3: Strings & Modules (Days 5) 10. 09_strings - String handling 11. 10_modules - Code organization 12. 11_hashmaps - More collections

Phase 4: Type System (Days 6-7) 13. 12_options - Null safety 14. 13_error_handling - Error management 15. 14_generics - Generic programming 16. 15_traits - Interface abstraction

Phase 5: Advanced (Days 8-10) 17. 16_lifetimes - Reference lifetimes 18. 17_tests - Testing 19. 18_iterators - Functional programming 20. 19_smart_pointers - Memory management 21. 20_threads - Concurrency 22. 21_macros - Metaprogramming 23. 22_clippy - Code quality 24. 23_conversions - Type conversions 25. quizzes - Assessment

Key Concepts Covered

Ownership & Borrowing

Move semantics
References and borrowing
Lifetimes
Smart pointers (Box, Rc, Arc, Cow)

Type System

Pattern matching
Enums and Options
Result for error handling
Generics and traits
Type conversions

Collections

Vectors
Strings
Hashmaps

Advanced Topics

Iterators and functional programming
Testing
Macros
Threading and concurrency
Error handling patterns

Resources

Official Documentation

The Rust Book - Comprehensive guide
Rust API Documentation - Standard library docs
Rust by Example - Practical examples

Learning

Rust Playground - Try Rust online
Clippy Lint Documentation - Code quality
Rustlings Official - Original project

Tools

rust-analyzer - IDE support
rustfmt - Code formatter
clippy - Linter

Tips for Learning

Read the README in each exercise directory - They provide valuable context
Understand the error messages - Rust's compiler is very helpful
Don't just copy solutions - Type them out to build muscle memory
Run tests frequently - cargo test is your friend
Experiment with variations - Try modifying working solutions
Use rust-analyzer - Get IDE support for better learning

Common Commands

# Run all tests
cargo test

# Run tests with output
cargo test -- --nocapture

# Check code without running
cargo check

# Format code
cargo fmt

# Run clippy linter
cargo clippy

# Build release version
cargo build --release

# View test file details
cargo test --doc

Contributing

This is a completed version of Rustlings. To:

Learn from solutions: Examine the exercise files in exercises/
Review solutions: Check the solutions/ directory
Understand concepts: Read the README files in each exercise category

License

Rustlings is licensed under the MIT license.

Acknowledgments

Rustlings was created by the Rust community to help new learners understand Rust concepts through practical exercises. This completed version includes all solutions for reference and learning purposes.

Happy Learning! 🎓🦀

If you have questions about specific concepts, refer to the official Rust documentation or the README files in each exercise directory.

README.md

Rustlings - Learn Rust the Fun Way! 🦀

Table of Contents