Core Concepts of Rust

Why Rust Feels Different

Rust’s biggest promise is memory safety without garbage collection. Instead of runtime checks for most memory rules, Rust enforces safety at compile time through ownership and borrowing.

This can feel strict at first, but that strictness removes entire classes of runtime bugs such as use-after-free and data races.

1. Ownership

Ownership is Rust’s foundation.

Rules:

1. Every value has one owner.
2. Ownership can move.
3. When owner goes out of scope, value is dropped.

fn consume(s: String) {
    println!("{s}");
}

fn main() {
    let name = String::from("calmops");
    consume(name);
    // println!("{name}"); // compile error: moved value
}

2. Borrowing

Borrowing lets you access data without taking ownership.

Types:

1. Immutable borrow: &T
2. Mutable borrow: &mut T

Rule set:

1. Any number of immutable borrows, or
2. Exactly one mutable borrow

Never both at the same time for the same data.

fn main() {
    let mut s = String::from("hello");

    let a = &s;
    let b = &s;
    println!("{a}, {b}");

    let c = &mut s;
    c.push_str(" world");
    println!("{c}");
}

3. Slices and String Views

Rust encourages borrowed views instead of ownership transfer where possible.

fn print_str(s: &str) {
    println!("{s}");
}

fn main() {
    let s = String::from("rust");
    print_str(&s); // &String coerces to &str
}

Using &str in APIs is often more flexible than &String.

4. Lifetimes

Lifetimes describe how long references stay valid.

Most lifetimes are inferred, but some signatures require explicit annotations.

fn longest<'a>(x: &'a str, y: &'a str) -> &'a str {
    if x.len() > y.len() { x } else { y }
}

This says returned reference lives at most as long as both inputs.

5. Structs, Enums, and Pattern Matching

Rust’s data modeling power comes from struct + enum + match.

enum Status {
    Pending,
    Running,
    Failed(String),
}

fn describe(s: Status) {
    match s {
        Status::Pending => println!("pending"),
        Status::Running => println!("running"),
        Status::Failed(msg) => println!("failed: {msg}"),
    }
}

Pattern matching is exhaustive, which prevents unhandled states.

6. Traits and Generics (Beginner Core)

Traits are Rust’s way of expressing shared behavior.

trait Summary {
    fn summary(&self) -> String;
}

struct Post {
    title: String,
}

impl Summary for Post {
    fn summary(&self) -> String {
        format!("Post: {}", self.title)
    }
}

Generics + traits let you write reusable code without sacrificing type safety.

7. Error Handling: Result and Option

Rust avoids null references. Absence and failure are explicit.

1. Option<T> for optional values.
2. Result<T, E> for recoverable errors.

fn parse_number(s: &str) -> Result<i32, std::num::ParseIntError> {
    s.parse::<i32>()
}

Use ? to propagate errors cleanly.

8. Ownership in Collections

Common beginner confusion: inserting into vectors/maps often moves ownership.

fn main() {
    let mut v = Vec::new();
    let s = String::from("abc");
    v.push(s);
    // println!("{s}"); // moved
}

Clone only when needed:

v.push(s.clone());

9. Concurrency Safety by Type System

Rust prevents many concurrency bugs at compile time using ownership + traits such as Send and Sync.

You still need design discipline, but data races in safe Rust are eliminated by default.

10. Common Beginner Pitfalls

1. Overusing clone instead of borrowing.
2. Returning references to local variables.
3. Fighting the borrow checker instead of redesigning ownership flow.
4. Using unwrap() everywhere in production code.

Practical Learning Sequence

Recommended order:

1. Ownership and borrowing.
2. Structs/enums and match.
3. Result/Option.
4. Traits and generics.
5. Lifetimes in function signatures.
6. Async and advanced concurrency later.

Conclusion

Rust’s core concepts are strict but coherent. Once ownership and borrowing click, many previously hard bugs become compile-time errors instead of runtime incidents.

Learn the model, not just syntax, and Rust becomes a powerful language for reliable systems.

Resources

• The Rust Book
• Rust by Example
• Rust Reference
• Rustlings