Rust Core: Key Concepts for Getting Started

Cover by author of ideogram.ai

Rust is a modern systems programming language focused on safety, speed, and concurrency. Whether you’re coming from Python, Java, C++, or starting fresh, understanding a few core concepts will get you productive quickly. This guide covers the essential elements that form the foundation of Rust programming.

1. Variables, Mutability, and Fundamental Types

Data is the cornerstone of any program. Let’s see how Rust handles it.

Variable Declaration: let, mut, and Shadowing

In Rust, variables are declared using the let keyword. By default, variables are immutable, promoting safer and more predictable code.

let x = 5; // x is immutable, its value is 5
// x = 6; // ERROR: cannot assign twice to an immutable variable

If you need to change a variable’s value, you must explicitly declare it as mutable using mut.

let mut y = 10; // y is mutable
println!("Initial y: {}", y); // Prints 10
y = 12; // OK, y is mutable
println!("Modified y: {}", y); // Prints 12

Rust also supports shadowing: you can declare a new variable with the same name as a previous one, effectively “shadowing” it. This is useful for transforming a value while keeping the same name, even changing its type.

let spaces = "   ";        // spaces is a string slice (&str)
let spaces = spaces.len(); // Now spaces is an integer (usize) holding the length
println!("Number of spaces: {}", spaces); // Prints 3

// Note: This differs from `mut`. With `mut`, you couldn't change the type:
// let mut spaces_mut = "   ";
// spaces_mut = spaces_mut.len(); // ERROR: expected &str, found usize

Best Practices:

• Default to immutability. Use mut only when modification is necessary.
• Use shadowing for value transformations or type changes while retaining a meaningful name.

Reference: Variables and Mutability — The Rust Programming Language

Basic Data Types

Rust is a statically typed language, meaning the type of every variable must be known at compile time. Often, the compiler can infer the type, but you can also specify it explicitly.

Here are some common scalar types:

• Integers: i8, u8, i16, u16, i32, u32, i64, u64, i128, u128. The number indicates bits, i denotes signed, u denotes unsigned.
• isize and usize: Architecture-dependent size (32 or 64 bits). Commonly used for indexing collections.
• Floating-Point Numbers: f32 (single-precision), f64 (double-precision, default).
• Booleans: bool (values true or false).
• Characters: char (represents a single Unicode scalar value, occupies 4 bytes).

let integer: i32 = -10;
let unsigned_int: u64 = 100;
let float_num: f64 = 3.14; // f64 is the default for floats
let is_active: bool = true;
let character: char = '🦀'; // Supports Unicode!
let index: usize = 0;

// Explicit type casting between numeric types
let a: u8 = 10;
let b: u32 = a as u32; // Use 'as' for casting

Reference: Data Types — The Rust Programming Language

The Crucial Difference: String vs. &str

Understanding the distinction between String and &str is fundamental in Rust:

String:

• An owned, heap-allocated data structure.
• It’s mutable and can grow in size.
• When a String goes out of scope, its memory is automatically deallocated (thanks to Ownership).
• Use String when you need to own, create, or modify string data at runtime (e.g., user input).

&str (pronounced "string slice"):

• A reference (borrow) to a sequence of UTF-8 bytes. It’s a “view” into string data that can reside on the stack, heap, or in static memory (like string literals).
• Usually immutable.
• Lightweight and fast, ideal for passing string data to functions without transferring ownership.
• All string literals (e.g., "hello") have the type &str.

let s_literal: &str = "I am a string literal"; // &str, stored in static memory
let mut s_heap: String = String::from("I am a String on the heap"); // String, owned

s_heap.push_str(", and I can grow!"); // OK, String is mutable

// You can get an &str from a String (borrowing)
let s_slice: &str = &s_heap; // Immutably borrows s_heap
// You can convert an &str to a String (allocating new memory)
let s_new_heap: String = s_literal.to_string();
// Functions often prefer &str for flexibility
fn print_string(s: &str) {
    println!("{}", s);
}
print_string(s_literal);
print_string(&s_heap); // Pass a reference (&str) to the String
print_string(s_slice);

Best Practices:

• Accept &str as function parameters when you don't need ownership or modification. This makes functions more flexible.
• Use String when you need to construct, modify, or return string data that the function or struct needs to own.

Reference: Understanding Ownership — The String Type, Slices

2. Functions and Control Flow

Code is organized into functions, and execution flow is managed by control structures.

Functions

Functions are reusable blocks of code. In Rust, define them with fn, specifying parameter types and (optionally) the return type. The last expression in a function is implicitly its return value (no trailing semicolon).

// Function taking two 32-bit integers and returning their sum
fn add(a: i32, b: i32) -> i32 {
    a + b // No semicolon; this is the return expression
}

fn main() {
    let result = add(5, 3);
    println!("The sum is: {}", result); // Prints 8
}

Reference: Functions — The Rust Programming Language

Control Flow: if, match, loop, while, for

• if/else: Executes code conditionally. if in Rust is an expression, meaning it can return a value.

let number = 6;
if number % 4 == 0 {
    println!("Number is divisible by 4");
} else if number % 3 == 0 {
    println!("Number is divisible by 3"); // This branch runs
} else {
    println!("Number is not divisible by 4 or 3");
}

let condition = true;
let value = if condition {
    5
} else {
    6
}; // 'if' as an expression
println!("The value is: {}", value); // Prints 5

• loop: Creates an infinite loop, exited using break.

let mut counter = 0;
loop {
    println!("Again!");
    counter += 1;
    if counter == 3 {
        break; // Exit the loop
    }
}

• while: Executes a loop as long as a condition remains true.

let mut number = 3;
while number != 0 {
    println!("{}!", number);
    number -= 1;
}
println!("LIFTOFF!!!");

• for: Iterates over elements of a collection or a range. This is the most common and idiomatic way to loop.

let a = [10, 20, 30, 40, 50];

// Iterate over array elements
for element in a.iter() { // .iter() borrows elements immutably
    println!("The value is: {}", element);
}

// Iterate over a range (exclusive end)
for number in 1..4 { // Prints 1, 2, 3
    println!("{}!", number);
}

// Iterate with index and value
for (index, value) in a.iter().enumerate() {
    println!("Index {}: {}", index, value);
}

• match: Powerful and safe pattern matching. Compares a value against a series of patterns and executes the code corresponding to the first matching pattern. match expressions must be exhaustive: all possible cases must be handled.

enum Direction {
    North,
    South,
    East,
    West
}

let d = Direction::East;
match d {
    Direction::North => println!("Heading North!"),
    Direction::South => println!("Heading South!"),
    Direction::East => println!("Heading East!"), // This matches
    Direction::West => println!("Heading West!"),
}

let status_code = 200;
match status_code {
    200 => println!("OK"),
    404 => println!("Not Found"),
    500..=599 => println!("Server Error"), // Inclusive range pattern
    _ => println!("Unknown code"), // Wildcard pattern for all other cases
}

// Match can also destructure and use guards
enum Response {
    Ok(i32),
    Err(String)
}

let r = Response::Ok(42);
match r {
    Response::Ok(val) if val > 40 => println!("High value: {}", val), // Match guard 'if'
    Response::Ok(val) => println!("Value: {}", val),
    Response::Err(msg) => println!("Error: {}", msg),
}

• if let: A more concise syntax when you are only interested in matching one specific pattern.

let maybe_value: Option<i32> = Some(5);

// Instead of a full match...
// match maybe_value {
//     Some(x) => println!("Value: {}", x),
//     None => {} // Ignore the None case
// }

// ...you can use if let:
if let Some(x) = maybe_value {
    println!("Value using if let: {}", x);
}

Reference: Control Flow — The Rust Programming Language, Pattern Matching — The Rust Book

3. Compound Types: Structs and Enums

Rust allows creating custom data types.

Structs (Structures)

structs group related data together. They are similar to classes (without inherent methods) or records in other languages.

struct User {
    username: String,
    email: String,
    active: bool,
    sign_in_count: u64,
}

fn main() {
    let mut user1 = User {
        email: String::from("someone@example.com"),
        username: String::from("someone123"),
        active: true,
        sign_in_count: 1,
    };

    user1.email = String::from("newemail@example.com"); // Access fields using dot notation
    println!("User email: {}", user1.email);
}

Reference: Structs — The Rust Programming Language

Enums (Enumerations)

enums define a type that can have one of several possible values (variants). Each variant can optionally hold associated data. They are extremely powerful when combined with match.

// Simple enum
enum Status { Active, Inactive, Suspended }

// Enum with associated data (Sum Type)
enum Message {
    Quit, // Variant with no data
    Move { x: i32, y: i32 }, // Variant with named fields (like a struct)
    Write(String), // Variant holding a String
    ChangeColor(i32, i32, i32), // Variant holding a tuple
}

fn process_message(msg: Message) {
    match msg {
        Message::Quit => println!("Quit received"),
        Message::Move { x, y } => println!("Move to x: {}, y: {}", x, y), // Destructuring
        Message::Write(text) => println!("Message: {}", text),
        Message::ChangeColor(r, g, b) => println!("Change color to R:{} G:{} B:{}", r, g, b),
    }
}

fn main() {
    let m1 = Message::Write(String::from("Hello Rust!"));
    process_message(m1);
}

Two fundamental enums in the standard library are Option<T> (for values that might be absent) and Result<T, E> (for operations that might fail).

• Option<T>: Has two variants: Some(T) (contains a value of type T) and None (contains no value). This is Rust's idiomatic way to handle potentially missing values, avoiding null pointer errors.
• Result<T, E>: Has two variants: Ok(T) (contains a success value of type T) and Err(E) (contains an error value of type E). This is the standard way to handle recoverable errors.

fn divide(numerator: f64, denominator: f64) -> Option<f64> {
    if denominator == 0.0 {
        None // Division by zero, return None
    } else {
        Some(numerator / denominator) // Return the result wrapped in Some
    }
}

fn main() {
    match divide(10.0, 2.0) {
        Some(res) => println!("Result: {}", res),
        None => println!("Cannot divide by zero!"),
    }
    match divide(10.0, 0.0) {
        Some(res) => println!("Result: {}", res),
        None => println!("Cannot divide by zero!"), // This gets printed
    }
}

Reference: Enums — The Rust Programming Language

4. Ownership and Borrowing: Rust’s Core Safety Feature

This is Rust’s most distinctive concept and the key to its memory safety without a garbage collector.

Ownership

1. Each value in Rust has a variable that’s called its owner.
2. There can only be one owner at a time.
3. When the owner goes out of scope, the value will be dropped (memory deallocated).

This system prevents errors like dangling pointers and double frees at compile time.

{ // s is not valid here, it’s not yet declared
    let s = String::from("hello"); // s is valid from this point forward
    // do stuff with s
} // this scope is now over, and s is no longer valid. Rust calls drop() for s.

let s1 = String::from("hello");
let s2 = s1; // s1 is "moved" into s2.
             // s1 is no longer valid to prevent double free issues.
// println!("s1 = {}", s1); // ERROR: value borrowed here after move
println!("s2 = {}", s2); // OK

Simple types like integers, booleans, floats, chars, which have a fixed, known size and live entirely on the stack, implement the Copy trait. For these types, assignment creates a bitwise copy instead of a move, and the original variable remains valid.

let x = 5; // i32 implements Copy
let y = x; // x is copied into y
println!("x = {}, y = {}", x, y); // OK, both x and y are valid (x is 5, y is 5)

Borrowing

Instead of transferring ownership, you can grant temporary access to a value using references. A reference is like a pointer that allows access to data without owning it.

There are two types of references (borrows):

1. Immutable References (&T):

• You can have multiple immutable references to the same data simultaneously.
• Holders of immutable references cannot modify the data.

1. Mutable References (&mut T):

• You can have only one mutable reference to a particular piece of data in a particular scope.
• The holder of a mutable reference can modify the data.
• Crucially: While a mutable reference exists, you cannot have any other references (mutable or immutable) to that same data.

These rules are enforced by the compiler (the borrow checker) and prevent data races at compile time.

fn calculate_length(s: &String) -> usize { // s is an immutable reference to a String
    s.len()
} // s goes out of scope here, but because it does not own the String, nothing happens.

fn change_string(s: &mut String) { // s is a mutable reference
    s.push_str(", world");
}

Lifetimes: Managing Reference Validity

After understanding Ownership and Borrowing, it’s crucial to grasp the concept of lifetimes: every reference in Rust must always be valid, and the compiler uses lifetimes to guarantee this.

A lifetime indicates how long a reference is valid. In practice, it prevents references from pointing to data that no longer exists (dangling references).

Intuitive Example

fn main() {
    let i = 3; // Lifetime of `i` starts here ────────────────┐
    {
        let borrow1 = &i; // Lifetime of borrow1 ────────┐   │
        println!("borrow1: {}", borrow1);               │   │
    } // borrow1 ends ──────────────────────────────────┘   │
    {
        let borrow2 = &i; // Lifetime of borrow2 ────────┐   │
        println!("borrow2: {}", borrow2);               │   │
    } // borrow2 ends ──────────────────────────────────┘   │
}   // Lifetime of i ends ─────────────────────────────────┘

Here, each reference to i is only valid while i exists.

Explicit Lifetimes in Functions

Usually, Rust can infer lifetimes, but sometimes you need to specify them:

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

fn main() {
    let s1 = String::from("hello");
    let s2 = "world";
    let result = longest(&s1, s2);
    println!("The longest reference is: {}", result);
}

• 'a is a lifetime parameter that ties the lifetime of x, y, and the return value together.
• This means: the returned value will be valid for at least as long as the input references.

Typical Error

If you try to return a reference to a local variable, Rust will give an error:

fn error_lifetime() -> &String {
    let s = String::from("hello");
    &s // ERROR: `s` is dropped at the end of the function!
}

Solution: only return references to data that outlive the returned reference.

Further Reading

• Lifetimes — Rust By Example
• Lifetimes — The Rust Book

fn main() {
    let s1 = String::from("hello");
    let len = calculate_length(&s1); // Pass an immutable reference
    println!("The length of '{}' is {}.", s1, len); // s1 is still valid here

    let mut s2 = String::from("hello");
    change_string(&mut s2); // Pass a mutable reference
    println!("{}", s2); // Prints "hello, world"

// Example of borrow checker rules:
    let mut s = String::from("test");
    let r1 = &s; // OK: immutable borrow
    let r2 = &s; // OK: another immutable borrow
    // let r3 = &mut s; // ERROR: cannot borrow `s` as mutable because it is also borrowed as immutable
    println!("{}, {}", r1, r2); // Use r1 and r2 - their scope effectively ends here
    let r3 = &mut s; // OK: r1 and r2 are no longer in use
    println!("{}", r3);
    // let r4 = &s; // ERROR: cannot borrow `s` as immutable because it is also borrowed as mutable
}

Reference: What is Ownership?, References and Borrowing

5. Traits: Defining Shared Behavior

Traits define shared functionality, similar to interfaces in other languages. They define a set of methods that a type must implement. Traits are the foundation of polymorphism and generics in Rust.

// Define a trait
trait Summary {
    fn summarize_author(&self) -> String; // Required method

    fn summarize(&self) -> String { // Method with a default implementation
        format!("(Read more from {}...)", self.summarize_author())
    }

// Another default method
    fn print_summary(&self) {
        println!("Summary: {}", self.summarize());
    }
}

// Implement the trait for a Struct type
struct NewsArticle {
    pub headline: String,
    pub author: String,
    pub content: String,
}

impl Summary for NewsArticle {
    fn summarize_author(&self) -> String {
        format!("{}", self.author)
    }
    // We could override summarize() here if needed, otherwise the default is used.
}

struct Tweet {
    pub username: String,
    pub content: String,
}

impl Summary for Tweet {
    fn summarize_author(&self) -> String {
        format!("@{}", self.username)
    }

    fn summarize(&self) -> String { // Overriding the default implementation
        format!("{}: {}", self.summarize_author(), self.content)
    }
}

// Generic function accepting any type that implements Summary
fn notify(item: &impl Summary) { // "impl Trait" syntax
    println!("Breaking news! {}", item.summarize());
}

// Alternative generic syntax with trait bounds
// fn notify<T: Summary>(item: &T) {
//     println!("Breaking news! {}", item.summarize());
// }

fn main() {
    let article = NewsArticle {
        headline: String::from("Rust is Awesome!"),
        author: String::from("Rustacean Dev"),
        content: String::from("Learning Rust opens up new possibilities..."),
    };
    let tweet = Tweet {
        username: String::from("rs_fan"),
        content: String::from("Loving traits! #rustlang"),
    };

    notify(&article);
    notify(&tweet);
    article.print_summary(); // Uses the default print_summary method
    tweet.print_summary();   // Uses the default print_summary method with overridden summarize
}

Many useful traits are provided by the standard library and can often be automatically implemented using the #[derive(...)] attribute:

• Debug: Enables formatted printing with {:?}.
• Clone: Enables explicit duplication via .clone().
• Copy: Enables implicit bitwise copy semantics (only for simple stack-allocated types).
• PartialEq, Eq: Enable equality comparisons (==).
• PartialOrd, Ord: Enable ordering comparisons (<, >).

#[derive(Debug, Clone, PartialEq)] // Automatically derive these traits
struct Point {
    x: i32,
    y: i32,
}

let p1 = Point { x: 1, y: 2 };
let p2 = p1.clone(); // Requires Clone

println!("Point: {:?}", p1); // Requires Debug
println!("Are they equal? {}", p1 == p2); // Requires PartialEq

Reference: Traits: Defining Shared Behavior

6. A Brief Look at Macros

You’ve likely seen println!, vec!, format!. The exclamation mark ! signifies that you're calling a macro, not a function.

Macros are a way of writing code that writes other code (metaprogramming). They are expanded by the compiler before the actual compilation phase. Macros are more powerful than functions:

• They can take a variable number of arguments (e.g., println!).
• They can generate trait implementations (e.g., #[derive(...)]).
• They can create custom syntax (DSLs — Domain Specific Languages).

// println! is a macro for printing to the console
println!("Hello, {}!", "world");

// vec! is a macro for easily creating a Vector (Vec)
let v = vec![1, 2, 3];
println!("Vector: {:?}", v);

While functions are preferred for business logic, macros are invaluable for reducing boilerplate code and performing tasks that functions cannot.

Reference: Macros — The Rust Programming Language

Conclusion

This guide has covered the fundamental pillars of Rust: variables, types (including the String/&str distinction), control flow (if, match, loops), custom types (struct, enum), the ownership and borrowing system, and traits for abstraction.

Mastering these concepts, especially ownership and borrowing, takes practice but rewards you with the ability to write extremely fast, safe, and concurrent code. The Rust compiler, with its detailed error messages, is an excellent guide during the learning process.

For deeper dives, the official Rust book is the best resource: The Rust Programming Language Book. Happy coding!