Syntax and Basics

Core Rust syntax you reach for in every file. Results appear in the same fence: same-line // comments when short, multiline // blocks below the sample when not.

let mut Binding

Bindings are immutable by default; mut allows reassignment.

let mut x = 5;
x = 6;
x  // 6

Type Inference

The compiler infers types; annotate when needed for clarity or ambiguity.

let n = 42;           // i32 by default for integers
let f: f64 = 2.5;
n + 1  // 43

Shadowing

Re-declare a name with let to transform type or value without mut.

let s = "42";
let s: i32 = s.parse().unwrap();
s  // 42

if Expression

if is an expression - branches must match types when used as a value.

let n = 7;
let label = if n > 5 { "big" } else { "small" };
label  // "big"

match Basics

Exhaustive pattern matching on enums and other types.

let x = 2;
match x {
    1 => "one",
    2 => "two",
    _ => "other",
}  // "two"

loop break Value

loop can return a value via break expr.

let mut n = 0;
let v = loop {
    n += 1;
    if n == 3 { break n * 10; }
};
v  // 30

while and for

while for conditions; for iterates ranges and collections.

let mut sum = 0;
for i in 1..=3 {
    sum += i;
}
sum  // 6

Function Return

Last expression without semicolon is the return value.

fn add(a: i32, b: i32) -> i32 {
    a + b
}
add(2, 3)  // 5

Tuple Destructure

Group values in tuples; destructure with let.

let t = (1, "a");
let (n, s) = t;
n  // 1
// s == "a"

Array and Slice

Fixed-size arrays; slices borrow a view into contiguous data.

let a = [10, 20, 30];
let s = &a[1..];
s[0]  // 20
a.len()  // 3

const and static

Compile-time constants vs long-lived statics.

const MAX: u32 = 100;
MAX  // 100
// static GLOBAL: i32 = 1;  // 'static lifetime

println Format

println! uses {} Display and {:?} Debug.

let name = "Ada";
// println!("hi {name}");  // hi Ada
format!("hi {name}")  // "hi Ada"

Type Cast as

Numeric casts use as carefully (truncation possible).

let n: f64 = 3.9;
n as i32  // 3

Block Expression

Blocks evaluate to their last expression.

let x = {
    let y = 2;
    y + 1
};
x  // 3

Unit Type

Functions with no return value return () the unit type.

fn log_hi() {
    let _ = "hi";
}
log_hi();  // ()

Related

• Ownership and Borrowing - how bindings interact with ownership
• Structs and Enums - custom data shapes
• Pattern Matching - match and if let depth

External Related Links

• The Rust Programming Language (The Book) - Canonical beginner-to-intermediate guide (ownership, borrowing, traits, etc.).
• Rust By Example - Runnable examples covering language features and standard library.
• Rust Playground - Online REPL for quick experiments.
• The Rust Programming Language, 3rd Edition (O'Reilly) - Klabnik, Nichols, Krycho.
• Rust in Action (Manning) - Tim McNamara.

Stack versions: Rust 1.97.0 · edition 2024 · Tokio 1.x · serde 1.0

49454e4f4d5f434e4f5904434556494d43451b121a56181a181c1a1d