Start Here: Your Rust Reading Journey 🗺️

Welcome! If you're reading this, you probably need to understand some Rust code but don't have time to become a Rust expert. Perfect - you're in the right place.

🎯 Your Goal

By the end of these guides, you'll be able to look at Rust code like this:

#![allow(unused)]
fn main() {
fn process_data(input: &str) -> Result<Vec<u32>, ParseError> {
    input.lines()
        .filter(|line| !line.is_empty())
        .map(|line| line.parse::<u32>())
        .collect()
}
}

And understand:

• What &str means (it's borrowing a string)
• Why there's a Result (Rust makes you handle errors)
• What that ? operator does (propagates errors upward)
• How the chain of methods works (iterator pattern)

🗺️ Your Learning Path

Step 1: Understand the Big Difference (Required)

Start with Ownership & Borrowing - This is Rust's most unique concept. Without understanding this, Rust code will seem mysterious. It's like trying to read Japanese without knowing it's read right-to-left.

Step 2: Core Concepts (Read in Order)

1. Types & Memory - How Rust organizes data
2. Error Handling - The Result/Option pattern
3. Pattern Matching - Rust's powerful match statement

Step 3: Deeper Patterns (Read as Needed)

• Traits & Generics - When you see impl Trait or <T>
• Lifetimes - When you see 'a or 'static
• Common Patterns - Idiomatic Rust you'll see everywhere

Step 4: Going Further

• Resources - Where to learn more

🔑 Key Things That Make Rust Different

Before diving in, here are the big ideas that make Rust unique:

1. Ownership is Explicit

In Python, you might write:

data = [1, 2, 3]
process(data)  # Can I still use data? Who knows!

In Rust, it's clear:

#![allow(unused)]
fn main() {
let data = vec![1, 2, 3];
process(data);  // data is MOVED - can't use it anymore
// OR
process(&data); // data is BORROWED - can still use it
}

2. No Null by Default

In Java:

String name = getUserName();  // Could be null!
name.length();  // Might crash!

In Rust:

#![allow(unused)]
fn main() {
let name: Option<String> = get_user_name();  // Explicitly might not exist
match name {
    Some(n) => n.len(),  // Must handle both cases
    None => 0,
}
}

3. Errors are Values, Not Exceptions

Instead of try/catch, Rust uses Result types that you must handle.

📊 Quick Recognition Patterns

When scanning Rust code, look for these common patterns:

🚩 Red Flags When Reading Rust

Watch out for these - they often indicate important logic:

1. unsafe - Raw memory manipulation, be extra careful
2. .unwrap() - Could panic/crash if None or Err
3. .clone() - Potentially expensive copy operation
4. Box<>, Rc<>, Arc<> - Heap allocation and reference counting
5. 'static - Data that lives for entire program

💭 Mental Models That Help

Rust is like a Library 📚

• You can own a book (you bought it)
• You can borrow a book (temporary access)
• You can mutably borrow (borrow with a pencil to make notes)
• Only one person can mutably borrow at a time
• When you're done borrowing, you give it back

Rust is like a Careful Chef 👨‍🍳

• Every ingredient is accounted for
• You know exactly who's using what
• No ingredient gets used after it's consumed
• Recipes (functions) declare what they need upfront

🎪 What Makes Rust Code "Rusty"?

Idiomatic Rust code tends to:

• Use iterators instead of loops when possible
• Return Result or Option instead of panicking
• Prefer borrowing over cloning
• Use pattern matching for control flow
• Keep mutations localized and explicit

✅ Quick Confidence Check

Can you guess what this does?

#![allow(unused)]
fn main() {
let numbers = vec![1, 2, 3, 4, 5];
let doubled: Vec<i32> = numbers.iter().map(|n| n * 2).collect();
}

If you guessed "creates a new vector with each number doubled" - you're ready to continue!

🚀 Next Steps

1. Must Read: Ownership & Borrowing - This is non-negotiable for understanding Rust
2. Then: Work through the core concepts in order
3. Finally: Reference the other guides as you encounter those patterns

Remember: You don't need to write Rust to read Rust. Focus on recognition, not memorization.

Ready? Let's tackle Ownership & Borrowing, Rust's signature concept! →