Rust.CodeCompared.To/Ruby

Ruby has no fn main() entry point, no println! macro, and no semicolons. Top-level code runs top to bottom the moment the file is loaded. puts writes a value followed by a newline — the everyday equivalent of println!.

Ruby is interpreted: there is no cargo build, no compiled binary, and no Cargo project structure needed for a script. ruby hello.rb parses and runs in one shot, and irb gives you an interactive REPL for quick experiments. The trade-off is that the Ruby interpreter must be present wherever the script runs.

Ruby uses # for single-line comments instead of //. For block comments it uses =begin/=end, which must start in column one — there is no /* ... */ form. The # style is overwhelmingly preferred; =begin/=end is rare in practice.

Ruby's require loads a library by name and its constants and methods become available in the global namespace — no qualifier like std::collections:: is needed afterward. The standard library ships with Ruby, so there is no Cargo.toml and no package download for built-in libraries.

In Rust, bindings are immutable by default and require let mut to allow mutation. In Ruby, all variables are mutable by default — there is no let keyword and there is no way to declare a binding as immutable. Reassignment is always permitted, and the type can change on every assignment.

Ruby constants are any identifiers that begin with a capital letter, conventionally written in SCREAMING_SNAKE_CASE. Unlike Rust's const, Ruby constants are not truly immutable — reassigning one emits only a warning rather than a compile error, so they rely on convention rather than enforcement.

Ruby has no type annotations. Variables spring into existence on first assignment and can hold any object at any time — the interpreter determines the type at runtime. There is no equivalent of Rust's i32, f64, &str, or bool declarations, and the type can change freely on reassignment.

Both languages support destructuring assignment. Ruby's splat operator *rest captures remaining elements into an array, with no separate exhaustive vs. non-exhaustive matching — it simply takes whatever is left. The splat can appear anywhere in the left-hand side: first, *middle, last = array.

Rust allows shadowing — creating a new let binding with the same name, which can even change the type while keeping the old binding's value in scope during initialization. Ruby simply reassigns the variable: the semantics are the same for simple cases, but the underlying mechanics differ since Ruby has no binding stack.

Rust has two string types: &str (a borrowed slice, often a string literal) and String (an owned, heap-allocated buffer). Ruby has a single String type that is always heap-allocated and always owned. There is no borrowing distinction to track, and the garbage collector handles cleanup automatically.

Ruby's string interpolation uses #{expression} inside double-quoted strings and can evaluate any Ruby expression inline — not just variable names. Rust's format! and println! macros use {name} or {} positional placeholders, which are checked at compile time but are macro calls rather than part of string syntax.

Ruby calls string methods directly on the string object — upcase vs. to_uppercase, include? vs. contains. Methods ending in ? conventionally return a boolean. Ruby's sub replaces the first match while gsub replaces all of them; no count argument is needed.

Ruby's format (aliased as sprintf) uses C-style format verbs — the same ones you know from printf!-style formatting. The difference is that format returns the formatted string rather than printing it, so it pairs with puts. The terse "%.2f" % price operator form also exists.

Ruby's heredoc syntax (<<~DELIMITER) strips leading indentation and is idiomatic for multiline strings embedded in code. Single-quoted strings suppress escape sequences — backslashes are literal — serving the same role as Rust's raw string literals (r"...") for paths and patterns.

Both languages perform integer division when both operands are integers. Where Rust requires an explicit type suffix or cast to f64, Ruby offers Integer#fdiv for a float result or you can simply write one literal as 7.0. The % remainder operator behaves identically in both.

Rust's integer types are fixed-width: i128 holds 2^100 but overflows at 2^200, and checked_pow returns None instead of silently wrapping. Ruby's Integer promotes to arbitrary precision automatically — 2 ** 200 returns an ordinary Integer with no external library or overflow to guard against.

Both languages support underscores in numeric literals for readability and the 0x (hex) and 0b (binary) prefixes. Ruby does not require type suffixes like _i64 or _f64 — the numeric type is inferred from the literal and can change on reassignment.

Rust's growable sequence is Vec<T>, which must be declared let mut to allow mutation. Ruby's Array is always mutable, heterogeneous by nature, and grows with push (or the append operator <<). Slicing uses a Range like 1..2 — inclusive on both ends — rather than Rust's half-open 1..3.

Ruby iterates by sending a block to a collection method — the collection controls the loop, not the caller. Note that each_with_index yields (element, index) in that order, the reverse of Rust's enumerate which yields (index, element). Ruby has no .iter() call; all objects respond to iteration methods directly.

Ruby's Enumerable module provides map, select, reject, reduce, sum, and dozens more on every collection, without the .iter() and .collect() calls that Rust's iterator pipeline requires. The &:even? shorthand turns a symbol into a block that calls the named method on each element.

Array#sort returns a new sorted array, leaving the original unchanged — use sort! to sort in place. For a custom key, sort_by takes a block that maps each element to its sort key and computes it only once, making it equivalent to Rust's sort_by_key but terser.

Ruby's Hash is a built-in literal — write { key => value } or use the symbol shorthand { name: value }. No use statement and no HashMap::new() are needed. Ruby hashes also preserve insertion order when iterated, unlike Rust's HashMap which provides no ordering guarantee.

Rust's HashMap::get returns Option<&V>, making the missing-key case explicit in the type system and forcing the caller to handle it. Ruby's [] returns nil for a missing key, which you check with .nil?. The fetch method lets you supply a default or raise KeyError when a key must be present.

Ruby drops the parentheses around the condition, closes blocks with end instead of braces, and uses elsif (not else if). It also has a postfix modifier form — puts "B" if score >= 80 — and an unless keyword for negated conditions, neither of which Rust provides.

Ruby's idiomatic style avoids explicit counter loops in favor of sending a block to an object: 3.times, (1..5).each, or array.each. This works because everything — including the integer 3 — is an object that responds to methods. The while loop is available for conditions that do not fit a simple iteration.

Ruby and Rust use opposite range conventions — easy to get wrong when switching between them. Rust's 1..5 is half-open (excludes 5) and 1..=5 is inclusive. Ruby's 1..5 is inclusive (includes 5) and 1...5 is exclusive (excludes 5). The extra dot in Ruby means "exclude the end."

Both languages treat if/else as an expression that evaluates to a value and can be assigned. Rust requires braces around each branch; Ruby uses then (or a newline) after the condition and closes with end. Ruby also supports the C-style ternary condition ? a : b.

Both use break to exit a loop early. Ruby uses next where Rust uses continue to skip to the next iteration. Ruby's loop do ... end corresponds to Rust's infinite loop {}, and postfix form is idiomatic: break if count == 3 reads like plain English.

A Ruby method needs no parameter types, no return type annotation, and usually no return keyword — the value of the last expression evaluated is returned automatically. Ruby 4.0 also supports an endless one-liner: def greet(name) = "Hello, #{name}".

Ruby supports named keyword arguments with optional defaults — a feature Rust lacks entirely. A keyword like port: 5432 is optional with a default value, while host: with no default is required. Callers pass keyword arguments by name in any order, eliminating the long positional argument lists that Rust forces.

Ruby's splat operator *numbers gathers any number of positional arguments into an array — the idiomatic equivalent of a Rust function that accepts a slice &[T]. At the call site, an existing array can be spread back into arguments with *: sum_numbers(*[1, 2, 3]).

Rust returns multiple values as a tuple destructured at the call site. Ruby simulates multiple return values by returning an Array and relying on parallel assignment to unpack it (low, high = ...). The splat form also works: first, *rest = [1, 2, 3] binds rest to [2, 3].

Rust accepts a closure as a generic function argument bounded by Fn, which must be declared in the function signature. Ruby uses yield — every method can implicitly receive one anonymous block without declaring it as a parameter. The block follows the method call, delimited by { ... } or do ... end.

Both languages have closures that capture surrounding variables. Rust closures that mutate captured state must use move and be typed as FnMut, and the caller variable must be let mut. A Ruby lambda (->) captures variables by reference automatically, and calling it with .call (or counter.() or counter[]) is always the same regardless of whether state is mutated.

The yield keyword is Ruby's signature feature — a method can pass control to an anonymous block the caller provided without declaring it as a parameter at all. This is how every Ruby iterator works: array.each, 3.times, and hash.select all yield to the caller's block. Rust has no equivalent; closures must always be declared explicitly in the function signature.

Ruby's block_given? tests whether the caller supplied a block, allowing a method to have both a default behavior and a block-customizable one. Rust achieves the same optionality with Option<F>, which must appear in the function signature explicitly. Ruby's approach is more flexible because the method does not need to know about the block at definition time.

A stored anonymous function in Ruby is a Proc or lambda. The & operator converts one into the block that a method expects, so map(&double) applies it to each element. The symbol form &:to_s is shorthand for "call to_s on each item" — one of the most widely used Ruby idioms.

Ruby's Enumerable provides the same lazy-pipeline feel as Rust's iterator adapters: select is filter, map is map, first(n) is take(n), and sum closes the chain. The Ruby version requires no .iter() to begin or .collect() to materialize — the result type is inferred automatically.

Rust separates data (struct) from behavior (impl block). Ruby combines both in a class body. State lives in instance variables prefixed with @, which are private by default; attr_accessor generates getter and setter methods. The constructor is always named initialize and is invoked by ClassName.new.

In Rust, impl Rectangle attaches methods to the struct in a separate block, and instance methods take &self as an explicit first parameter. In Ruby, methods are defined inside the class body and implicitly operate on self without declaring it — the receiver is always the current object.

Rust has no classical inheritance — shared behavior is composed through traits, not parent classes. Ruby has single inheritance with class Dog < Animal; a subclass can override a method and reach the parent's version with super. This "is-a" relationship gives Ruby a simpler model for behavior reuse compared to Rust's composition-only approach.

Ruby classes are open — you can reopen any class, including built-in ones like String, Integer, or Array, and add or redefine methods at runtime. Rust extension traits provide a similar capability within your own crate, but the orphan rule prevents adding methods to external types. Ruby's openness is more powerful but carries the responsibility not to surprise other code.

Ruby's Comparable mixin — activated with include Comparable and a single <=> ("spaceship") operator — grants <, >, <=, >=, sort, min, max, between?, and clamp for free. Rust requires implementing Ord, PartialOrd, PartialEq, and Eq separately — far more boilerplate for the same result.

Both mod (Rust) and module (Ruby) serve as namespaces accessed with ::. The key difference is that Ruby modules serve a dual role: in addition to namespacing, they can be included as mixins that inject method implementations into a class — a role Rust separates into traits.

A Ruby module included as a mixin injects its method implementations directly into the class — calling include Greetable means User objects respond to hello with no interface declaration or type annotation. Rust traits with default method implementations are the closest equivalent, but the type must still explicitly impl the trait.

Enumerable is the most powerful Ruby mixin — include Enumerable and define one method (each) to gain more than 50 methods: map, select, reject, min, max, sum, group_by, tally, flat_map, and many more. Rust achieves the same through the Iterator trait's default methods, but you must always enter the pipeline explicitly with .iter().

Both languages support operator overloading. Ruby defines operators as ordinary methods — def +, def ==, def [] — and the interpreter calls them when the operator is used. Rust implements the corresponding standard trait (Add, PartialEq, Index) — a more structured approach that leverages the type system.

Rust enums are sum types enforced by the compiler — every match must handle every variant or it will not compile. Ruby uses symbols (:north) as lightweight, immutable identifiers in place of simple enums, combined with case/when for dispatch. The switch is not exhaustiveness-checked, so an unmatched value silently returns nil.

Rust enums can carry data — each variant is essentially an anonymous struct. Ruby has no built-in equivalent, but hash pattern matching (case/in) achieves a similar dispatch: the pattern destructures the hash and binds its keys as local variables. The Ruby approach is flexible but provides no compile-time exhaustiveness guarantee.

A Ruby Symbol (:name) is an immutable, interned identifier — :north is always the exact same object in memory regardless of where it appears, making identity comparison (equal?) and equality (==) identical. Symbols are the idiomatic key type for hashes acting as records, and the &:method shorthand depends on them. Rust has no equivalent.

This is the deepest philosophical split between the two languages. Rust returns errors as ordinary Result values that the caller must inspect before using the value. Ruby raises exceptions that unwind the call stack until a rescue catches them — the happy path is never interrupted by error checks, and failures propagate automatically until something handles them.

Rust's Option<T> makes the presence or absence of a value part of the type — the compiler forces you to handle None before accessing the inner value. Ruby uses nil as the universal "no value", checked with .nil? or the || short-circuit. The Ruby approach is simpler but provides no compile-time guarantee that the missing case has been handled.

Rust's ? operator is early-return sugar for Result — if the expression is Err, the function returns that error immediately. Ruby achieves the same propagation through exceptions: a failure in Integer(...) raises ArgumentError, which travels up the call stack automatically without any explicit check at the call site.

Rust's memory and resource cleanup happens deterministically through RAII — when a value's scope ends, its Drop implementation runs automatically. Ruby's ensure clause is explicit: it runs when a method or begin block exits, whether normally or via an exception, and is the place to close files, release locks, or finalize resources.

A Rust custom error implements Display (for human-readable messages) and optionally Error and Debug. A Ruby custom exception is a class that inherits from StandardError. The rescue clause matches by class — rescue NotFoundError catches only that class and its subclasses — making it easy to build an exception hierarchy.

Ruby's case/when maps closely to Rust's match. Both support multiple values in one arm (comma in Ruby, | in Rust) and range patterns. The key difference is exhaustiveness: Rust requires a _ wildcard to compile if not all cases are covered, while Ruby's case silently returns nil for an unmatched value.

Ruby's case/in syntax (stable since Ruby 3.0) provides structural pattern matching that mirrors Rust's match very closely. Both support destructuring and variable binding in the same clause. Ruby uses square brackets for arrays where Rust uses parentheses for tuples — the semantics are otherwise identical.

Ruby's hash pattern is one of the most concise forms in the language. A pattern like { role: "admin", name: } both checks that :role equals "admin" and binds :name's value to the local variable name in one clause. Rust must manually extract and test map values since it has no native hash pattern syntax.

Both Rust and Ruby pattern matching support guard conditions — a filter applied after the structural pattern succeeds. Rust uses if condition inline; Ruby's case/in also uses if. A guard is checked only if the structural pattern already matched, so the behavior is identical. Ruby also supports range patterns like (..0) for "up to and including 0."

Both thread::spawn (Rust) and Thread.new (Ruby) launch threads, and join waits for them. The critical difference: Rust threads run truly in parallel — the borrow checker prevents data races at compile time. Ruby's standard interpreter (CRuby) has a global interpreter lock (GIL) that prevents pure-Ruby threads from running on multiple CPU cores simultaneously; they shine for concurrent I/O, not CPU-bound parallelism.

Rust requires Arc<Mutex<T>> to safely share mutable state across threads — the borrow checker enforces this at compile time and the pattern is verbose but correct by construction. Ruby's Mutex#synchronize takes a block and releases the lock automatically when the block exits (even on an exception), removing the need to manually pair lock and unlock.

Thread#value blocks until the thread finishes and returns the value of its block — so threads.map(&:value) collects all results in order with no explicit synchronization. Rust's handle.join().unwrap() does the same per handle; iterating with map achieves the same collection pattern but requires more ceremony.