Ruby.CodeCompared.To/Rust

Both languages make values immutable by default — Ruby freezes strings in 4.0; Rust requires let mut for any reassignable binding. Rust's println! is a macro (note the !), not a function — it is checked at compile time. Named format captures like {name} work without extra arguments.

Rust shadowing re-declares a binding with let, creating a new variable (potentially with a different type). Ruby reassignment reuses the same slot; Rust shadowing is conceptually a new binding. Unlike let mut, shadowing can change the type.

Rust is statically typed with type inference — types are known at compile time but rarely need to be written explicitly. There is no nil; absent values use Option<T>. Integer overflow panics in debug mode and wraps in release mode.

Rust uses as for numeric casts — infallible but potentially lossy (3.9 as i32 is 3). Parsing from strings returns Result and requires error handling. Unlike Ruby, Rust will not silently coerce between numeric types.

Rust has two string types. &str is a borrowed reference to UTF-8 bytes — use it for read-only access and function parameters. String owns its data — use it when building or mutating. Convert: "hello".to_string() or String::from("hello"); back: &my_string.

The + operator on String consumes the left-hand side — after let r = greeting + ..., greeting is gone. Use format!() to avoid this. String indexing by integer (e.g. s[0]) is not allowed in Rust because UTF-8 characters are variable-width; use .chars().nth(n).

vec![] creates a Vec<T>. Index access panics if out of bounds; use .get(i) which returns Option<&T> for safe access. first() and last() return Option rather than Ruby's nil. Fixed-size arrays [T; N] have a compile-time size; Vec<T> is the growable equivalent.

HashMap must be brought into scope with use. Unlike Ruby Hash, iteration order is not guaranteed. scores["Alice"] would panic on a missing key; use .get("Alice") which returns Option<&V>. The .entry(key).or_insert(val) API is idiomatic for insert-if-absent.

Rust tuples have a fixed length and may contain mixed types. Elements are accessed by index .0, .1, etc. Destructuring works like Ruby's parallel assignment. The empty tuple () is the "unit type" — the implicit return value of functions that return nothing meaningful.

In both languages, if is an expression that returns a value. Rust requires curly braces around every branch — no then keyword. All branches must return the same type; if one returns "A", all must return &str.

Rust's match is exhaustive — the compiler rejects non-exhaustive matches. Ranges use ..= for inclusive end (like Ruby's ..). The _ wildcard is like Ruby's bare else. Unlike Ruby case, all arms must return the same type.

Rust has no times method — use for i in 0..n. Ranges are exclusive at the end by default (0..3 = 0,1,2); use ..= for inclusive. loop is Rust's infinite loop — it can break with a value, the closest equivalent to Ruby's loop { break value if ... }.

Return type is annotated with ->. The last expression in a block without a semicolon is the return value — explicit return is valid but mainly used for early exit. Rust has no keyword arguments; use a builder pattern or a struct with Default for optional parameters.

Both languages return multiple values via a tuple/array with destructuring on the receiving side. &[i32] is a slice — a borrowed view into any contiguous sequence of i32, whether from a Vec or a fixed array. It is the idiomatic parameter type for "read a sequence".

Rust closures use |params| syntax and capture their environment by reference by default. Add move before | to capture by value (required when the closure outlives its scope, e.g. in threads). Rust distinguishes Fn, FnMut, FnOnce — the compiler infers which applies.

Rust uses generics (<F: Fn(...)>) or trait objects (dyn Fn(...)) to accept closures. impl Fn(...) as a return type means "some type that implements this closure trait". move is required in make_adder so the closure captures n by value and can outlive the function call.

Rust's ownership system replaces garbage collection. When a value is assigned or passed to a function, it is moved unless the type implements Copy. After a move, the original binding is invalid — the compiler enforces this. clone() explicitly makes a deep copy. This is the biggest conceptual shift for Rubyists.

&T is an immutable reference (borrow) — any number can exist simultaneously. &mut T is a mutable reference — only one can exist at a time, and not alongside any immutable references. These rules are enforced at compile time by the borrow checker. Ruby achieves safety via runtime GC; Rust achieves it at zero runtime cost.

Option<T> is Rust's explicit representation of an optional value: Some(T) holds a value; None represents absence. The type system forces you to handle the missing case — no more NoMethodError: undefined method for nil. &. (safe navigation) becomes .map() or if let Some(...).

Rust has no exceptions. Functions that can fail return Result<T, E>. The ? operator (see Error Handling section) propagates errors to the caller, similar to raise. unwrap() gives the value or panics (like an uncaught exception). expect("msg") is the same but with a better panic message.

Rust iterators are lazy — they produce no values until consumed by .collect(), .sum(), .count(), etc. Chaining map().filter() is a single pass with no intermediate allocations. min() and max() return Option in case the collection is empty.

Method chaining looks almost identical in both languages. The key difference is that Rust chains describe a pipeline evaluated in a single pass; Ruby's each method returns a new Array. flat_map works the same way in both: map then flatten one level.

Rust separates data (struct) from behavior (impl). &self is an immutable reference to the instance; &mut self allows mutation. There are no class hierarchies — Rust uses traits for shared behavior. The Display trait is Rust's equivalent of to_s.

The ..base struct update syntax fills unspecified fields from another instance. #[derive(Debug)] auto-generates the {:?} formatter. The Default trait provides default values — Rust's idiomatic equivalent of Ruby's default keyword arguments.

Traits are Rust's equivalent of Ruby modules used as mixins. A trait defines an interface and can provide default implementations. Unlike Ruby's include, you must explicitly impl TraitName for TypeName. &impl Greetable as a parameter type means "any type implementing Greetable" — compile-time duck typing.

Rust enums are far more powerful than Ruby symbols — each variant can carry data. match on an enum is exhaustive: omitting any variant is a compile error, which prevents bugs from unhandled cases. Derive Debug to get {:?} formatting for free.

Each Rust enum variant can hold different data — Circle(f64) holds one float, Rectangle(f64, f64) holds two. Pattern matching destructures the data inline. This is far more expressive than Ruby's symbol-based dispatch and eliminates the need for a separate lookup table or struct.

The ? operator is shorthand for "return early with the error if this is Err, otherwise unwrap the Ok value". It is Rust's idiomatic alternative to begin/rescue chains. ? only works in functions returning Result or Option. The function signature signals to callers that it can fail.

Custom error types implement Display for user-facing messages. In real codebases, the thiserror crate eliminates this boilerplate; anyhow provides a simple catch-all error type similar to Ruby's StandardError. Both require adding to Cargo.toml.

Rust's ownership system makes data races a compile-time error — you cannot share mutable data across threads without explicit synchronization. Arc<T> is an atomically reference-counted pointer (thread-safe). Mutex<T> wraps a value and requires locking before access. Unlike Ruby's GIL, Rust threads achieve true parallelism.

mpsc = "multiple producer, single consumer". The channel closes automatically when all senders are dropped — no need for a sentinel value like Ruby's :done. Iterating over receiver blocks until messages arrive and terminates when the channel closes. Use sync_channel(n) for a bounded channel.

Rust's mod organizes code; pub marks items as public (like Ruby's public visibility). Everything is private by default. In a real project, modules live in separate files (geometry.rs) and are declared with mod geometry;. use brings paths into scope — like Ruby's require at the file level, but without adding methods to types.

Rust requires let mut for any variable that will be reassigned. This is enforced at compile time and eliminates whole classes of bugs from accidental mutation. Shadowing (let x = x + 1) is not mutation — it creates a new binding and the type can change.

Rust has no nil. Any value that might be absent must be explicitly wrapped in Option<T>. The type system tells you exactly which values can be absent — no more NoMethodError: undefined method for nil:NilClass. The compiler forces you to handle None before using the value.

Rust integers do not auto-promote or extend to arbitrary precision. Mixing i32 and f64 in an expression is a compile error — you must cast with as. Overflow panics in debug builds (catching bugs) and wraps silently in release builds. Use checked_add, saturating_add, or wrapping_add for explicit overflow handling.

Rust's str is UTF-8. Indexing by integer position is a compile error because a Unicode character can take 1–4 bytes. Use .chars() to iterate over characters, .chars().nth(n) for positional access, and .len() for byte length. This is stricter than Ruby but prevents subtle Unicode bugs.