PHP.CodeCompared.To/Rust

Output uses println! — the trailing ! marks it a macro, not a function, because it does compile-time checking of the format string. It appends a newline for you, so you do not write \n. There is no <?php tag and no $ on variables.

Rust is compiled ahead of time to a self-contained native binary with no interpreter or garbage collector to ship — like C, but memory-safe. Cargo is the standard tool (PHP's Composer plus a build system): cargo new, cargo build, cargo run, and crates from crates.io.

The format string captures variables inline ({name}), much like PHP's "{$name}", or takes positional arguments with empty {}. The {:?} form is Debug output — a developer-facing representation of almost any value, akin to var_export.

The biggest habit change: a let binding is immutable by default. To reassign, you must opt in with let mut. This is the opposite of PHP, where every variable is freely mutable, and it pushes you toward code where what can change is explicit.

Rust has a family of sized numeric types — i32, i64, u8, usize, f32, f64 — instead of PHP's single int and float. It also has a distinct char type for one Unicode scalar (single quotes), separate from strings; PHP has no character type.

Rust lets you shadow a name by declaring let again, even changing the type (here &str to i32). Unlike PHP's reassignment, each let creates a fresh immutable binding, which is the idiomatic way to transform a value through stages without a mutable variable.

Rust splits strings into two types: &str, a borrowed view (often a literal), and String, a growable, heap-owned buffer. You build and mutate a String; you pass around &str to read. PHP's single mutable string covers both roles, so this distinction is new and central.

String slices have chainable methods (text.trim().to_uppercase()) replacing the free functions strtoupper(trim($text)). Note these return new String values rather than mutating in place — Rust's immutability-by-default extends to strings.

The format! macro is println!'s sibling that returns a String instead of printing — the counterpart to PHP's sprintf, but with the same inline-capture and placeholder syntax as println!.

PHP's one array type splits into a Vec<T> (a growable, homogeneously typed list) and a HashMap<K, V> for key-value data. Both are generic over their element types, fixed at compile time, so a Vec<i32> can never hold a string. There are also fixed-size arrays [i32; 3].

A Vec exposes methods — push, sort, len, contains — replacing array_push, sort, count, and in_array. Note contains(&2) takes a reference, and the vector must be mut to push or sort.

Rust's iterator adapters filter and map chain left-to-right and are lazy — nothing runs until collect() consumes them into a concrete Vec. This is more readable than PHP's inside-out array_map(array_filter(...)), and the closures capture variables like PHP arrow functions.

Iterating a map with for (name, score) in &scores destructures each entry, like foreach ... as $name => $score. The & borrows the map so you can keep using it afterward. Unlike a PHP array, a HashMap has no guaranteed order, so this example sums rather than printing per-entry.

In Rust if is an expression that yields a value, so it replaces the ternary operator (which Rust does not have): the last expression in each branch becomes the result. Conditions take no parentheses, and every branch must produce the same type.

Rust has no C-style three-part for; you iterate over a range (0..3, which stops before 3) or any iterable. The foreach-over-values form maps to for letter in [...]. Rust also has loop { } for an infinite loop and while.

Both languages have a value-returning match, and PHP's was partly inspired by Rust's. Rust's is more powerful: arms are patterns, if guards refine them, the wildcard is _ instead of default, and the compiler enforces that the match is exhaustive.

Rust's defining idea: every value has a single owner, and assigning a heap value moves ownership, invalidating the old binding. This is how Rust frees memory deterministically with no garbage collector. To keep both, you clone() explicitly. PHP's reference-counted runtime hides all of this from you.

To use a value without taking ownership, you borrow it with & — a reference. The function reads &Vec<i32> and the caller keeps the original. The borrow checker enforces the rules (many readers OR one writer at a time), preventing data races at compile time — guarantees PHP's value-copy model never needs to make.

A &mut reference lets a function mutate the caller's value — the parallel of PHP's &$items by-reference parameter. The difference is that Rust permits only one mutable borrow at a time (and none while shared borrows exist), which is what makes the no-data-race guarantee possible.

Functions use fn, with parameter types after each name and the return type after a -> arrow. The killer convenience: the final expression is the return value — drop the semicolon and omit return. An explicit return still works for early exits.

A Rust closure uses pipe-delimited parameters |value| ... and captures surrounding variables automatically, like PHP's arrow function fn() =>. The compiler infers how it captures (by reference, or by move with the move keyword) based on what the body does.

Rust returns multiple values as a typed tuple (i32, i32), which the caller destructures with let (low, high) — much like PHP's "return an array, then destructure", but each position has its own static type. The &[i32] parameter is a slice, a borrowed view over any array or Vec.

Rust separates data (the struct) from behavior (an impl block of methods). Methods take &self explicitly — the parallel of $this — and you construct with Point { x: 3, y: 4 }, no new keyword. There is no class; this split is the Rust way.

Rust has no built-in constructor; the convention is an associated function named new (no self parameter), called as Circle::new(...) — the rough equivalent of a PHP static factory. Self is shorthand for the type being implemented, like PHP's self.

Rust generates common behavior with a #[derive(...)] attribute: Debug enables {:?} printing, PartialEq enables ==, and Clone enables .clone(). PHP grants object value-comparison and var_dump automatically; Rust makes you opt in, which keeps the costs explicit.

Both languages have rich enums with methods. The syntax rhymes: variants are listed, and methods live in an impl block matching on self. Rust enums go further still — each variant can carry its own typed data, which makes them the foundation of Option and Result below.

Rust has no null. A value that might be absent is an Option<T> — either Some(value) or None — and the compiler forces you to handle the None case before using the value. unwrap_or supplies a default, the parallel of PHP's ??, but you can never accidentally dereference a null.

The if let construct matches one pattern and binds its contents in a single line — here it unwraps Some(name) only when the Option is present. It is the concise alternative to a full match when you care about just one case, with no PHP equivalent beyond isset-and-assign.

A trait is Rust's interface: it declares method signatures, and a type provides them with impl Trait for Type — separating the contract from the data. Unlike PHP interfaces, traits can supply default method bodies and can be implemented for types you do not own, which is far more flexible.

Confusingly, PHP also has a feature called "traits", but it is a code-reuse mixin. Rust's trait is closer to an interface with optional default methods: greet here has a body that any implementor inherits for free, while name must be provided — combining PHP's interface and trait concepts into one.

Generics are a real, compile-time feature: <T> is a type parameter, here bounded by T: Copy so the value can be returned by copy. Rust monomorphizes generics — it generates a specialized version per concrete type — so there is no runtime cost. PHP can only approximate this with @template docblocks for static analysers.

Structs can be generic too: Wrapper<T> holds a value of any type, and the impl block can require trait bounds like T: Display so the body may print it. This gives you type-safe containers — what the standard library's Vec<T> and Option<T> are built on — with no PHP equivalent.

Rust has no exceptions. A fallible operation returns a Result<T, E> — either Ok(value) or Err(error) — and the compiler forces you to handle both, so an error can never be silently ignored. This is the opposite of PHP's throw-and-maybe-catch model, where an uncaught exception unwinds at runtime.

The ? operator is Rust's ergonomic error propagation: parse_value(input)? unwraps an Ok or returns the Err from the enclosing function immediately. It gives you the "let it bubble up" convenience of PHP exceptions while keeping every error path visible in the type signatures.

For genuinely unrecoverable bugs, panic! aborts the current thread with a message, much like an uncaught exception ending a PHP script. The distinction Rust draws is deliberate: use Result for expected, recoverable failures and reserve panic! for "this should never happen" invariants.

Rust's integers are fixed-width and typed (i32, u64, …), and overflow is a real concern: it panics in debug builds rather than silently promoting to a float like PHP. You choose the behavior explicitly with methods like wrapping_add, checked_add, or saturating_add.

Rust performs no implicit numeric coercion — you cannot even multiply an i64 by an f64 without an explicit as cast, and there is no string/number juggling at all. This eliminates the "5" + 3 surprises of PHP, at the cost of writing the conversions yourself.

Because Rust has no null, the "forgot to check for null" bug simply cannot occur — absence is modeled as Option and the compiler refuses to let you use the inner value without handling None. The ? operator works on Option too, making the safe path the short one.

The borrow checker enforces that you cannot mutate a collection while an iteration borrow over it is still alive — a class of aliasing bug PHP allows at runtime. Fighting the borrow checker is the usual early-Rust experience; it is the compiler proving your memory and aliasing are sound before the program ever runs.