Dart.CodeCompared.To/Rust

The ! on println! marks it as a macro, expanded at compile time — that is how it type-checks its format arguments, something an ordinary function cannot do. vec!, format!, and assert! are macros too. Rust is compiled ahead of time to a native binary with no runtime or garbage collector, which is the root of nearly every difference on this page.

Rust inverts Dart's default: a plain let is immutable (like final), and you must write let mut to allow reassignment (Dart's var). Immutability here is deep and compiler-enforced — a let binding to a struct freezes its fields too — which the borrow checker relies on. Reaching for mut is a conscious, visible choice rather than the path of least resistance.

Local type inference is strong, as in Dart, but the integer type still matters — 42 is an i32 by default, and Rust does no implicit numeric widening. Interpolation is unusual: println!("{answer}") captures a variable by name (edition 2021+), or you use positional {} holes filled by later arguments. There is no $ sigil and the placeholders are checked at compile time.

Rust has no ternary operator, because it does not need one: if/else is an expression that yields a value, so let grade = if … { … } else { … } does the ternary's job. Both arms must produce the same type. The same is true of match and block expressions, so assigning the result of a control-flow construct is idiomatic — much as in Dart's switch expressions.

In Dart second = first aliases one heap object. In Rust it moves ownership: first is statically invalidated, so using it afterward is a compile error, not a run-time surprise. This guarantees exactly one owner frees the memory, exactly once, with no GC and no double-free. Types that are cheap to duplicate (integers, bool, char) are Copy instead and are duplicated rather than moved.

Passing a value to a function would normally move it, so to keep using it you borrow instead: &words lends a read-only reference, and the caller retains ownership. You may have any number of shared & borrows at once. The compiler tracks these borrows and forbids using the value in ways that would conflict — the core of how Rust prevents dangling references without a garbage collector.

To mutate through a borrow you need a &mut reference, and the receiver must itself be mut. The key rule: you may have either many shared & borrows or exactly one &mut, never both at once. This "shared XOR mutable" law is what makes data races impossible at compile time — a guarantee Dart provides only by having a single thread per isolate.

Small, stack-only types (i32, bool, char, tuples of them) implement Copy, so assignment duplicates them and the original stays valid. Heap-owning types like String and Vec are not Copy — duplicating them is a potentially expensive deep copy you must request with .clone(). Rust makes that cost visible in the source, where Dart's implicit sharing hides it entirely.

Where Dart tracks nullability with ? on the type, Rust makes absence a real value in an enum: Option<String>. You cannot accidentally use a None as a string — there is no value to dereference — so the entire category of null-dereference bugs is gone by construction, a step beyond even Dart's sound null safety. match is one way to unwrap it; the combinators below are terser.

Rust's Option comes with a rich toolkit that replaces Dart's null-aware operators: unwrap_or(default) is ??, if let Some(x) = … is a one-branch unwrap (like ?. plus a check), and .map(|x| …) transforms the value only when it is present. These combinators keep you from ever writing an explicit null test, and chain cleanly — opt.map(…).unwrap_or(…).

A Result makes failure part of the return type, so a caller cannot ignore it the way an unchecked Dart exception can slip past. There is no stack unwinding for this — the error is a value you pattern-match, pass along, or transform. It is more explicit than Dart's try/catch, and the ? operator (next) removes almost all of the ceremony.

The ? operator is Rust's answer to exception propagation: applied to a Result, it unwraps an Ok or returns the Err from the current function immediately. It turns a chain of fallible calls into readable straight-line code — let a = step_one()?; let b = step_two(a)?; — recovering the convenience of Dart's automatic exception propagation while keeping the failure visible in every signature.

Rust does have panic! — triggered by numbers[99], .unwrap() on a None, or an explicit call — but it is reserved for unrecoverable bugs, not normal error flow, and by default it aborts the thread. The recoverable alternative is a method that returns Option/Result, like .get(index) here. The rule of thumb: return a Result for anything a caller might reasonably handle, and reach for panic! only when continuing would be a mistake.

A Rust struct holds data and nothing else — there is no constructor, so you build one with field syntax Point { x: 3, y: 4 } (a convention is a Point::new associated function when you want validation). There are no classes and no inheritance; behavior is added separately through impl blocks (next) and shared through traits. Fields are private to the defining module unless marked pub.

Methods live in an impl block, separate from the data. A method takes &self (a borrow of the receiver), &mut self to mutate, or self to consume it — the ownership rules again. A function without a self parameter is an associated function, Dart's static method, called with :: — which is how constructors like Rectangle::square and String::from are written.

The #[derive(...)] attribute auto-generates trait implementations, sparing you the Dart boilerplate on the left: PartialEq gives structural ==, Clone a deep copy, Debug the {:?} formatting, and Hash/Eq make a type usable as a map key. It is Rust's counterpart to Kotlin's data class — one line replacing dozens — but à la carte, deriving exactly the capabilities you ask for.

A Rust enum is an algebraic data type: each variant can carry its own fields, so a Dart sealed hierarchy collapses into one enum Shape — the same shape as Swift and Kotlin's sealed answers, and the tool Rust reaches for constantly (Option and Result are just enums). It is closed and exhaustively matchable, which the next concept leans on.

Rust's match is the ancestor of Dart 3's pattern switch, and they are close cousins: range patterns (1..=3), guards (v if v < 0), and value binding all line up. The defining rule is exhaustiveness — the compiler rejects a match that misses a case, so you either handle every variant or add a _ catch-all. On an enum that means adding a variant surfaces every match that must be updated.

A trait is Rust's interface: a set of method signatures a type can implement with impl Trait for Type. Unlike Dart, conformance is explicit and lives outside the type — you can implement your own trait for a built-in type like i32 — and traits, not base classes, are the whole abstraction story, since there is no inheritance. Standard traits like Display, Iterator, and From wire your types into the language.

A trait method can ship a default body, so a conformer only implements the required pieces and inherits the rest — exactly the role Dart mixins play, and the mechanism behind Iterator giving you map, filter, and dozens more from a single required next. Combined with impl Trait for Type, default methods cover both the mixin and the "extension methods" use cases in one feature.

A heterogeneous collection of "things that speak" needs dynamic dispatch, spelled Box<dyn Speaker> — a trait object behind a pointer, resolved at run time like a Dart interface reference. The dyn keyword makes the cost explicit, because Rust's default is the opposite: generic <T: Speaker> bounds (next section) are monomorphized into specialized code with no run-time lookup. You choose per use whether you want the flexibility or the speed.

A Dart List is a Rust Vec<T>, built with the vec! macro and homogeneous (every element is the same type T). It must be mut to push, and accessors that might miss — first, get(i) — return an Option rather than risking a null. Printing a whole collection uses the debug formatter {:?}, since Vec has no plain Display.

A HashMap must be brought in with use std::collections::HashMap — it is not in the prelude — and lookups return an Option (get) rather than null. The entry(...).or_insert(...) API elegantly handles "insert if absent, otherwise update," which in Dart takes the ?? 0 dance on the left; it is the idiomatic way to count or accumulate into a map.

Rust splits Dart's single String into two types that trip up every newcomer: String is an owned, growable, heap-allocated string, while &str is a borrowed, immutable view into one (string literals are &str). The rule of thumb mirrors ownership: take &str as a function parameter to accept both cheaply, return or store an owned String. It is the string-sized version of the borrow-vs-own decision.

Rust iterators are lazy like Dart's Iterable: filter and map build a pipeline that does no work until a consumer like collect, sum, or a for loop drives it. Two Rust specifics: you start the chain with .iter() (which yields references, hence the & patterns), and collect() often needs a target type annotation (Vec<i32>) to know what to build. The whole chain compiles down to a tight loop with no allocation per stage — "zero-cost."

Dart's fold is Rust's fold(seed, |acc, x| …), and the same reductions have dedicated, clearer methods: sum(), product(), max()/min() (which return an Option, since the iterator might be empty). Rust's reduce exists too and, like Dart's seedless reduce, returns an Option rather than risking an empty-collection error — the null-safety discipline reaching into the collection API.

Like Go, Rust has no named arguments, default parameter values, or overloading — a real adjustment from Dart's expressive parameter lists. The idiomatic replacements are an options struct (as here, often paired with #[derive(Default)] and ..Default::default() to fill the rest) or the builder pattern for larger APIs. It keeps call sites explicit at the cost of the brevity Dart offers.

Closures are written with pipes, |n| n * n, and capture their environment like Dart's. The Rust-specific wrinkle is how they capture: by reference by default, or by value when you write move (required when the closure outlives the captured variable, e.g. handed to a thread). Under the hood closures implement the Fn/FnMut/FnOnce traits depending on how they use their captures — detail Dart's uniform closures never expose.

Generic syntax rhymes with Dart, but the bound is a trait: <T: PartialOrd + Copy> means "any type that can be ordered and is cheap to copy," and you can require several traits with +. Rust monomorphizes generics — it stamps out a specialized copy for each concrete type at compile time — so there is no boxing and no run-time cost, unlike Dart's single reified implementation. The bound is also a contract the compiler checks at the definition, not just at each call.

Rust has real OS threads with shared memory, spawned by thread::spawn and awaited with join — closer to Dart's isolates in spirit than to its single-threaded Futures, but sharing one heap rather than copying messages. What makes it "fearless" is that the ownership and Send/Sync rules are enforced across threads too, so the compiler rejects code that could race. (Rust also has async/await, but it needs an external runtime like tokio, so it is beyond this std-only playground.)

To share mutable state across threads you wrap it in Arc<Mutex<T>>: Arc (atomic reference count) gives several threads shared ownership, and Mutex guards the data so only one thread mutates at a time — lock() returns a guard that unlocks when it drops. The compiler will not let you share a plain value or forget the lock, so the data race that a Dart programmer never had to think about (isolates share nothing) is caught at compile time rather than left to discipline.

Rust organizes code into modules declared with mod (which can nest and can live in separate files), and everything is private by default — you export with the pub keyword, the inverse of Dart's "public unless underscore-prefixed." You pull names into scope with use (Dart's import), and paths use ::. A whole compiled library is a crate, the unit Cargo manages next. The Dart side references a second file, so its column is display-only.

Dart's pubspec.yaml plus dart pub get corresponds to Cargo.toml plus Cargo, Rust's build tool and package manager (cargo build, cargo run, cargo test). Packages are crates from crates.io, and the version syntax rhymes: Cargo's "1.0" is a caret requirement by default, the same compatible-update rule as Dart's ^1.2.0.