Visual Basic.CodeCompared.To/F#

F# runs top-level code the way a script does: no Module, no Sub Main, no End. Console.WriteLine "Hello, World!" works too, because the whole base class library is right there. printfn is preferred because its format string is type-checked at compile time — the next row shows what that buys you.

$"..." works exactly as in Visual Basic. The other form uses typed placeholders: %s for a string, %d for an integer, %.2f for a rounded float, %b for a boolean, %A for "show me the structure". Passing the wrong type is a compile error, which String.Format("{0}") can never be. %A is the one you will reach for constantly — it prints records, lists and tuples readably with no ToString to write.

A script or a single-file program simply runs its top-level bindings in order. A compiled executable marks one function with the [<EntryPoint>] attribute; it must be the last declaration in the last file, take a string array, and return an int exit code. Note that F# compiles files strictly in order and a name must be defined before it is used — there is no forward reference and no equivalent of a Module whose members are all visible at once.

A block is delimited by indentation, as in Python — there is no End If, no End Sub, no braces. Then survives, in lower case. Tabs are rejected outright, not merely discouraged. The upside for a Visual Basic reader is that the shape of the code barely changes: delete the End lines, lower-case the keywords, and the indentation was already right.

' becomes //, and there is a block form (* ... *) which Visual Basic has never had. The documentation comment ''' becomes /// and takes the same XML tags — <summary>, <param>, <returns> — because both compilers emit the same documentation file. This is the first of many places where staying on .NET means you carry your tooling with you.

Identifiers are case-sensitive, so customerName and CustomerName are two bindings. F# convention is camelCase for let-bound values and functions and PascalCase for types, modules and public members — which differs from .NET's usual PascalCase-everything precisely because most F# values are local rather than public API.

Dim becomes let, and a let binding cannot be reassigned — let means "this name refers to this value", not "this box holds this value". When you genuinely need a variable, let mutable declares one and <- assigns to it; the different operator means you can always see mutation on the page. Most F# code has very little of it, which is the point: a value that cannot change cannot be changed by accident from somewhere else.

F# infers types across whole functions, not just single assignments, so add is typed int -> int -> int with nothing declared. This is stronger than Option Infer, which only infers a variable from its initializer. Annotations are still available and use the same right-to-left order as As Integer: (value: string) : int. You need them where inference cannot decide, most often to pick which type a member call belongs to.

Integer→int, Long→int64 (L suffix), Double→float, Single→float32, Decimal→decimal (m suffix, lower case). The strictness goes beyond Option Strict On: F# performs no implicit conversion whatsoever, including widening, so adding an int to a float is a compile error until you write float whole. Conversion functions are named after the target type — int, float, string, decimal.

An option is either Some value or None, and the compiler will not let you use the value without handling both. That is the difference from Nothing: a String that might be Nothing looks exactly like one that cannot be, so nothing reminds you to check. Option.defaultValue is the two-argument If(); Option.map transforms the value if there is one. F# code that stays inside F# rarely sees a null at all — nulls arrive from C# libraries at the boundary.

= is equality, not assignment, and <> is inequality — both exactly as you write them today. F# can afford this because assignment to a mutable binding uses a different operator, <-. Equality is structural by default: two records or lists with the same contents are equal, with no Equals to override. There is no truthiness — a condition must be a bool.

x |> f means f x — it feeds the value on the left into the function on the right as its last argument. That is all it is, and it is why every List function takes the collection last. The result reads top to bottom in the order the work happens, exactly like a method chain, but works with any function at all rather than only methods defined on the type. Chained backwards it is <|, and >> composes two functions into one without mentioning a value.

There is no \: 17 / 5 between two ints truncates to 3, so a Visual Basic / copied across silently changes meaning. Because F# does no implicit conversion, the fix is explicit on both sides — 17.0 / 5.0, not 17 / 5.0, which will not compile. Mod becomes %, and ^ becomes ** and works only on floats. In F# ^ concatenates strings, so writing it out of habit is a type error rather than a wrong answer.

Because F# is a .NET language, Trim, ToUpper, Contains, Replace and Length are the same members you already call, spelled the same way. What is new is the String module — String.filter, String.map, String.concat — which treats a string as a sequence of characters and composes with the pipeline. Method calls need their arguments parenthesized when they are part of a larger expression, which is the main visual adjustment.

Unlike Visual Basic, F# treats \ as an escape, so "C:\reports" means something else. @"..." is the verbatim form, identical to C#'s. Triple quotes give a literal that spans lines and honors nothing at all — not even a doubled quote — which makes it the right home for JSON and regular expressions. String concatenation is +, and ^ also works but is rarely used.

An F# list is an immutable singly-linked list, written with semicolons because the comma builds a tuple. There is no Add: :: ("cons") produces a new list with an item on the front, and @ concatenates. Because the tail is shared, prepending is cheap and appending is not — which is why F# code prepends and reverses rather than appending in a loop. It is not List(Of T); that type is ResizeArray in F#, and it is still there when you want it.

Where→List.filter, Select→List.map, Any→List.exists, All→List.forall, FirstOrDefault→List.tryFind (which returns an option), OrderBy→List.sortBy, Aggregate→List.fold, GroupBy→List.groupBy. The same names exist under Array and Seq; Seq is IEnumerable<T> and is the lazy one, so it is what LINQ itself most resembles. All the LINQ extension methods still work too, since these are .NET collections.

An F# array is a .NET array — fixed length, mutable, indexed with .[i] and assigned with <-. Array.zeroCreate 3 takes a count, not an upper bound, so Dim scores(2) becomes zeroCreate 3. A Map is the immutable dictionary: Map.add returns a new map rather than changing the old one. Map.tryFind returns an option, which is TryGetValue without the output parameter. The mutable Dictionary(Of K, V) is still available under its own name.

ElseIf becomes elif, and the whole if is an expression whose value is the chosen branch. Every branch must therefore have the same type, and an if with no else must be of type unit — meaning it does something rather than producing something. That rule is what stops the "declared but not yet assigned" state the anchor column passes through.

Select Case x→match x with, each Case becomes a | arm, Case Else becomes | _. Case 2, 3 becomes | 2 | 3. A range or a comparison becomes a guard: | n when n > 100 binds the value and adds a condition. The compiler checks that the arms are exhaustive and warns when one can never be reached — neither of which Select Case can do, because a Visual Basic Integer has no closed set of values.

For index = 1 To 5 becomes for index in 1 .. 5 do, and the range is inclusive at both ends, so there is no off-by-one to convert. Step -2 becomes the middle element of 10 .. -2 .. 0. For Each becomes the same for ... in. While ... End While becomes while ... do. There is no Do ... Loop Until and no Exit For or Continue For at all — a loop that needs to stop early is written as a recursive function or a Seq pipeline instead.

There is no Sub/Function split: a function that returns nothing returns unit, written (), which is F#'s void. There is no Return — the last expression is the result. Arguments are applied by juxtaposition: add 2 3, not add(2, 3). Writing the parenthesized form still compiles but means something subtly different — it passes a tuple — which the currying row explains.

A two-argument F# function is really a function that takes one argument and returns a function taking the next — that is currying, and its type is written int -> int -> int for exactly that reason. So multiply 2 is a perfectly good value: a function awaiting one more argument. This is why the pipeline works so smoothly, and why List.map double reads as it does. Visual Basic has no counterpart; the nearest thing is writing the lambda by hand every time.

Function(value) value * 2 becomes fun value -> value * 2. There is no separate Sub() form and no Func/Action type to declare — a function type is written int -> int. The addition is composition: f >> g builds a new function that applies f then g, without naming the value at all. Compare it with |>, which pushes a value through; >> joins two functions into one.

F# compiles top to bottom, so a name is not in scope inside its own definition unless marked let rec. The second example shows the idiom that replaces a mutable accumulator loop: an inner loop function carrying the state as arguments. Because the recursive call is the last thing it does, the compiler turns it into an actual loop — tail-call optimization — so it does not grow the stack. Visual Basic has no such guarantee, which is why deep recursion is avoided there.

A record gets value-based equality and a useful %A rendering for free, which is the whole anchor column written for you. It is immutable, so with produces a copy with named fields changed rather than mutating. Records are ordinary .NET classes underneath, so C# and Visual Basic can consume them. Note that field names begin with a capital and that the type is inferred at the construction site — no : Person annotation needed.

A discriminated union says "a Shape is a Circle or a Rectangle, and nothing else". The whole class hierarchy in the anchor column collapses to three lines, the casts disappear because match binds the fields directly, and — the important part — the compiler warns if a case is unhandled. Add a Triangle and every incomplete match in the program lights up, which is the opposite of the anchor column, where the missing branch surfaces as a runtime exception.

Tuples need no declaration: (a, b) has type int * string, and the * is read as "and". Destructuring on the left of a let pulls the parts out, and fst and snd reach into a pair. F# tuples have no field names, unlike Visual Basic's, so when the parts deserve names the answer is a record. Since C# 7 both languages share the same underlying ValueTuple, so tuples cross the language boundary intact.

Attaching a unit of measure to a numeric type makes metres and seconds different types, so adding them is a compile error while dividing them correctly produces float<m/s>. The units are erased at compile time, so the arithmetic is exactly as fast as plain float. There is nothing like this in Visual Basic or C#, and it is the kind of mistake — mixing pounds with kilograms, cents with dollars — that a business application actually makes.

The parentheses after the type name are the primary constructor: type Counter() = takes no arguments, type Person(name: string) = takes one, and the body between it and the first member is the constructor. A let inside a class is a private field. member declares a public member; the _ is where you would name this. A member with no parentheses is a property, which is why Total and Increment() differ. New Counter() becomes just Counter().

Implements becomes interface ... with. The rule to know: F# implements interfaces explicitly by default, so the method is reachable only through the interface type — hence the upcast :> before calling it. The addition is the object expression: { new IGreeter with ... } creates a one-off implementation with no class declaration, which is what you use where C# would reach for a lambda or a tiny private class.

A Visual Basic Module and an F# module are the same idea and compile to the same thing: a static class. Imports becomes open, which brings a module or namespace's names into scope exactly as you expect. Modules nest, and a file with no module declaration gets one named after the file. This is the closest structural correspondence anywhere on the page — most of a Visual Basic Module ports almost line for line.

StringBuilder, Dictionary<K,V>, DateTime, every NuGet package and every class you have written are all available unchanged. Generic arguments use angle brackets rather than (Of ...), and an indexer is .[key]. The one new habit: F# insists every expression's value is used, so a method returning something you do not want — like StringBuilder.Append, which returns the builder — needs |> ignore or the compiler warns.

Catch x As T becomes an arm of a match: | :? FormatException as error ->, where :? is the type test. Throw becomes raise, and Throw New ArgumentException(...) becomes failwith "message" for the quick case. The one structural surprise: F# has no try/with/finally in a single block, so a try ... finally has to wrap a try ... with, as above.

A Result is Ok value or Error reason, and the compiler makes you handle both — so it is the Boolean-plus-ByRef idiom with the failure carrying information and the success value impossible to read by mistake. Result.map transforms a success and passes an error straight through, which lets a chain of fallible steps be written without a single If. Exceptions are still available and still right for genuinely exceptional things; Result is for failures you expect.

Async Function ... As Task(Of T) becomes task { ... }. Await splits in two: let! x = ... when you want the value and do! ... when you do not. Return becomes return. These are computation expressions, a general mechanism — async { }, seq { }, option { } and library-defined ones all use the same shape, which is why learning it once pays off repeatedly. Everything is still System.Threading.Tasks underneath, so it interoperates with Visual Basic and C# freely.

Visual Basic reserves \ for integer division; F# has no \, and / between two ints truncates. What saves you here more often than in C# is that F# will not silently widen: writing (3 + 4) / 2.0 is a compile error rather than a wrong answer, because you cannot divide an int by a float. You must convert explicitly, and being made to write float is exactly the prompt to think about it.

F# compiles strictly top to bottom: a name must be defined before it is used. Inside a file that is a mild adjustment. Across a project it is a real one — the order of files in the project file is significant, and rearranging them can break the build. It feels restrictive at first and turns out to be a feature: the dependency graph is a straight line, so there are no circular references between modules, ever. Mutually recursive definitions, when genuinely needed, are joined with and.

Each let total = ... introduces a new binding that hides the previous one for the rest of the scope; the old value is untouched, and anything already capturing it still sees the old one. Inside a function the effect resembles assignment closely enough to mislead — and stops resembling it the moment a closure or a loop is involved, because the shadowed binding does not persist across iterations. (At module level F# refuses outright: two lets with one name is Duplicate definition of value, which is why the example puts them inside a function.) When you want a value that changes over time, say so with let mutable and <-.

F# expects every expression in a sequence to have type unit — "no meaningful value". A method that returns something you do not want, which fluent .NET APIs do constantly, therefore needs |> ignore. It is noise the first few times and then becomes useful: the warning has caught a genuinely forgotten result at least once for everyone who writes F#. unit is written (), and a Sub becomes a function returning it.

Everything under System is unchanged — Environment, DateTime, Int32.TryParse — and note that F# turns an out parameter into part of a tuple, so TryParse returns (bool, int) and needs no ByRef. What is gone is the My namespace, the Microsoft.VisualBasic functions (IsNumeric, MsgBox, Now) and, in practice, the visual designer: F# has no supported WinForms designer, so a form is written in code or the application becomes a web service. That is the real cost of this move, and it is worth weighing before starting.