Visual Basic.CodeCompared.To/Rust

Module disappears — a Rust file is a module already — and Sub Main() becomes fn main(). The ! means println! is a macro, not a function: it is expanded at compile time, which is how it can check its format string against its arguments and accept a variable number of them. Braces replace End, statements end with semicolons, and nothing is imported because println! is in the prelude.

A name in braces is interpolated directly, so $"{name}" becomes "{name}" with no prefix. Format specifiers differ in vocabulary but not in idea: D5 becomes :05, F2 becomes :.2. The two additions are {:?}, the debug format, which prints any type that derives Debug — collections, structs, tuples — and {:#?}, the same thing pretty-printed across lines. Between them they remove most of the reasons to write a ToString override.

Rust warns about an unused variable and tells you what to write instead — prefix it with _. That is representative: borrow-checker errors name the two conflicting uses and their lines, type errors suggest the conversion, and many messages come with a rustc --explain code and a worked explanation. Expect to spend your first weeks fighting the compiler and your later ones grateful for it; the messages are the teaching material, not an obstacle to it.

Dim becomes let, and a let binding is immutable — reassigning it is a compile error. let mut is the variable you meant. This is not stylistic: immutability is what lets the compiler reason about who may touch what, which is the whole ownership system. Const becomes const and requires an explicit type. Type annotations, where needed, read right to left as As Integer does: let count: u32 = 10.

An if, a match, a loop and even a bare block all evaluate to something — the last expression inside, written without a semicolon. Adding a semicolon turns an expression into a statement and its value becomes (), the unit type, which is the single most common cause of a confusing early error message. A function body works the same way, which is why return is usually unnecessary.

Names are case-sensitive as everywhere else on this anchor. What is unusual is that Rust warns about the convention: snake_case for variables, functions and modules, CamelCase for types and traits, SCREAMING_SNAKE_CASE for constants. Writing customerName compiles but produces a non_snake_case warning, so the whole ecosystem looks alike — as with gofmt, and for the same reason.

Assigning a value moves it: original gives up ownership and using it afterwards is a compile error. There is no garbage collector, so the compiler tracks who owns each value and frees it when that owner goes out of scope — deterministically, with no runtime cost. Small copyable types (integers, bool, char) implement Copy and are duplicated instead. Where .NET gives two names to one list and lets either mutate it, Rust makes you say which one owns it.

A borrow, written &value, lends access without transferring ownership, so the caller keeps the value. A parameter typed Vec<i32> takes ownership; one typed &[i32] borrows. This is information a .NET signature simply does not carry: Total(values As List(Of Integer)) tells you nothing about whether the method will keep a reference, store it somewhere, or mutate it. In Rust that is all in the type, and the compiler enforces it.

At any moment a value may have either one mutable borrow or any number of immutable ones, never both. That single rule is what makes a data race impossible without unsafe, and it is also what will reject perfectly reasonable-looking code while you are learning. In .NET nothing stops two references mutating one list from two threads; here the compiler will not build it. The cost is that some designs — a doubly linked list, a graph with back-references — need Rc, RefCell or an index-based layout instead.

clone() is the deep copy, and it is always written out — so an expensive duplication is visible at every call site rather than hidden behind an assignment. Cleanup is the other half: when a value's owner goes out of scope its Drop implementation runs, at that exact point. That is what Using/IDisposable approximates in .NET, except that here it is automatic, cannot be forgotten, and applies to every type — there is no finalizer, no GC pause, and no Dispose to remember.

&str is a borrowed view of text — what a literal is — and String is an owned, growable buffer. A function usually takes &str (accepting both) and returns String. Convert with to_string() or String::from. The other surprise: len() is the length in bytes, not characters, because Rust strings are UTF-8 — chars().count() is what .Length meant, and indexing by character position is deliberately not offered.

Short→i16, Integer→i32, Long→i64, Byte→u8, Double→f64, Single→f32; usize is the pointer-sized integer used for lengths and indices. Conversion needs as, even widening. Overflow is checked in debug builds and panics rather than wrapping, and checked_add returns an Option so you can handle it — a level of care .NET only offers behind a compiler switch. There is no Decimal; money uses integer minor units or the rust_decimal crate.

A struct holds data and an impl block holds its methods, declared separately. #[derive(...)] asks the compiler to generate implementations: Debug for {:?} printing, PartialEq for ==, Clone for explicit copying, Hash, Default, PartialOrd. There is no constructor keyword — the convention is an associated function called new, invoked with ::. &self is Me, and taking it by reference means the method borrows rather than consumes.

This is the same idea as F#'s discriminated union, and the whole class hierarchy in the anchor column collapses into four lines. The casts vanish because match destructures the variant directly. The part that matters most: match must cover every variant, so adding a Triangle turns every incomplete match in the program into a compile error — where the anchor column would keep building and fail at runtime. A Visual Basic Enum is an Integer underneath and can hold a value you never declared; a Rust enum cannot.

Rust has no null. A value that might be missing has type Option<T>, which is Some(value) or None, and the compiler will not let you use the inner value without handling both. That eliminates the null-reference error as a category, not merely as a common bug. unwrap_or is the two-argument If(), map transforms the value if present, and if let is the shorthand for "do this only in the Some case".

List(Of String) becomes Vec<String>, built with the vec! macro. Add becomes push, Count becomes len(), and it must be declared mut to grow. Indexing with [0] panics if out of range; get(index) returns an Option instead, and so does first(). Preferring the Option-returning form is how Rust code avoids the whole family of index-out-of-range crashes.

Dictionary(Of K, V) becomes HashMap<K, V>, needing use std::collections::HashMap. TryGetValue becomes get, which returns Option<&V> — so a missing key is in the type, not in a boolean and an output parameter. entry(key).or_insert(default) is the "get it or create it" idiom that replaces a check-then-insert pair, and it is what makes a tally loop one line. Iteration order is unspecified, as it is in Go.

Where→filter, Select→map, Any→any, All→all, FirstOrDefault→find, Aggregate→fold, ToList→collect. Chains are lazy like LINQ, but with a difference that matters: they are zero-cost, compiling to the same machine code as a hand-written loop with no allocation per stage. Note .iter() borrows, .into_iter() consumes, and the double && in the filter closure is the borrow of a borrow the compiler will tell you about.

Case 2, 3 becomes 2 | 3, Case 4 To 6 becomes the inclusive range 4..=6, Case Is > 100 becomes a guard n if n > 100, and Case Else becomes _. It is an expression, so the Returns disappear, and it must be exhaustive — leave a case out and it will not compile. That exhaustiveness is what makes the enums in the previous section safe to extend.

For index = 1 To 5 becomes for index in 1..=5 — the ..= is inclusive, .. is exclusive, so the off-by-one is a choice rather than an accident. For Each becomes the same for ... in, and &words borrows so the vector survives the loop. while exists, and loop is the infinite form — with the twist that break value makes the whole loop an expression. Labels ('outer:) let break leave an enclosing loop.

if let Some(x) = ... matches one pattern and binds it, running the block only on success — the common half of a match. let ... else is the inverse and is the closest thing Rust has to a guard clause: it binds on success and must diverge (return, break or panic) on failure, so the bound name is available for the rest of the function with no nesting. Both replace what TryGetValue plus an If does, with the value only in scope where it is valid.

Sub becomes an fn with no ->; Function ... As Integer becomes -> i32. A function returns its final expression, which must have no semicolon — adding one turns it into a statement and produces a "mismatched types: expected i32, found ()" error, the classic first Rust mistake. return exists for early exits. Every parameter type is mandatory; only local let bindings infer.

Function(value) value * factor becomes |value| value * factor. There is no Func/Action type: a closure's type is one of three traits describing how it uses what it captured — Fn (borrows), FnMut (borrows mutably), FnOnce (consumes). A function taking a closure declares impl Fn(i32) -> i32. Adding move before the bars forces the closure to take ownership of what it captures, which is what you need to send one to another thread.

Rust has no exceptions. A fallible function returns Result<T, E> — Ok(value) or Err(problem) — and the compiler warns loudly if the result is discarded. So every failure path is visible in the signature, exactly as in Go, with one improvement: because Result is an ordinary enum, forgetting to handle it is a type error rather than a forgotten if. TryParse's boolean-plus-ByRef becomes this, with room for a reason.

The ? operator unwraps an Ok and returns the Err from the enclosing function if it is one. So the three-line if err != nil dance that Go needs becomes a single character, and error propagation reads almost like exceptions — with the crucial difference that ? is visible on the page, so you can see exactly which calls can bail out. It works on Option too, and converts between error types automatically when a From conversion exists.

A panic! unwinds and normally ends the program — it is not catchable in the ordinary way, so it is for bugs, not for a missing file. unwrap() panics if the value is None or Err, and expect("...") does the same with a message you wrote. Both are fine in tests and prototypes and are a smell in production code: reach for unwrap_or, match, or ? instead. Where the anchor column catches an index error and carries on, the Rust equivalent is to use get() and never panic at all.

Interface becomes trait and Implements becomes a separate impl Trait for Type block, which means you can implement your trait for someone else's type — a capability .NET has no equivalent for. Traits may carry default methods, like a Java default or a Ruby mixin. Box<dyn Greeter> is the "any type implementing this" form used when the concrete type varies at runtime; impl Greeter in a signature is the compile-time version and costs nothing.

(Of T As IComparable(Of T)) becomes <T: PartialOrd + Copy>, listing the traits T must implement, joined with +. The bound lets the compiler check the body against the constraint rather than trusting a cast. The deep difference: Rust generics are monomorphized — a separate specialized copy is compiled for each concrete type — so there is no boxing, no runtime type lookup, and largest(&[3, 9, 2]) is exactly as fast as a hand-written integer version.

Cargo.toml is the .vbproj, crates.io is nuget.org, and Cargo.lock pins versions. What comes in the box: cargo test (tests written in the same file as the code, in a #[cfg(test)] module), cargo fmt (non-negotiable formatting, as with gofmt), cargo clippy (a very good linter), and cargo doc. The build produces one binary with no runtime to install — the same deployment story as Go, and a much smaller one than shipping .NET.

Namespace and Module both become mod, nested with :: rather than dots. Imports becomes use, which brings a name into scope — and unlike Go, it really does shorten the call. The default is private: pub is required to expose anything outside its module, which is the opposite of Visual Basic's default-public members. A file is a module and a directory is a module tree, so the layout on disk is the namespace hierarchy.

Modifying a collection while iterating it throws InvalidOperationException in .NET, after the program has shipped. In Rust it is a borrow-checker error: the loop holds an immutable borrow, push needs a mutable one, and both cannot exist at once. Expect to meet this constantly at first, and expect the fix to be a restructure — collect what you need, then apply it — rather than a workaround. The compiler is usually right, and the code it forces you toward is usually better.

There is no \, so / between two integers truncates and the fix is an explicit as f64 — Rust will not widen for you. Overflow is the more interesting half, and Visual Basic comes out of it well: it checks by default and throws OverflowException, which C# does not (C# wraps silently unless you write checked). Rust panics in a debug build and wraps in a release build, which is the worst of both unless you are explicit — so the standard library offers checked_add (returns Option), saturating_add (clamps at the limit) and wrapping_add (wraps on purpose), and production code should name the one it means rather than relying on the build profile.

text[3] does not compile — a byte index into UTF-8 is meaningless, so Rust will not offer it. len() counts bytes, so "café".len() is 5 while chars().count() is 4. Slicing by byte range works but panics if it lands inside a character. This is genuinely more work than Mid and .Length, and it is the reason Rust programs do not have the class of bug where a Turkish name or an emoji corrupts a substring.

There is no class inheritance: an abstract base class with shared behaviour becomes a trait with default methods, and "is-a" hierarchies become composition plus traits. There is no null, so the null-reference exception does not exist as a category. There is no Overridable and no method overloading either. Reaching for a base class is the most common way a ported .NET design fights Rust; designing around traits from the start is much less painful than translating a hierarchy.

My.Computer.FileSystem becomes std::fs, IsNumeric becomes parse::<i32>().is_ok(), and environment access is std::env. But Rust's standard library is small on purpose: there is no date/time type beyond raw durations (the chrono or time crate supplies one), no HTTP client, no JSON. Those come from crates.io, which is a healthier ecosystem than that sounds. There is no MsgBox and no designer — a desktop application means egui or Tauri, and most Rust work is services, tooling and systems code.