Ruby.CodeCompared.To/F#

printfn prints a string followed by a newline — the direct equivalent of Ruby's puts. F# top-level expressions execute in order, just like a Ruby script.

F# top-level code runs sequentially. Each printfn call is an IO action — the program executes them in order, like Ruby's procedural style.

printf is like Ruby's print — no trailing newline. printfn is like puts — adds a newline. Both accept format specifiers like %s, %d, and %A.

F# inherits printf-style format specifiers: %s for strings, %d for integers, %f for floats, %b for booleans, and %A for any value using F#'s default pretty-printer.

F# 5+ supports string interpolation with $"..." syntax, equivalent to Ruby's #{}. Any expression is valid inside the braces. For format control, use $"%.2f{price}" or switch to format specifiers.

In F#, let creates an immutable binding — name cannot be reassigned. All let bindings are immutable by default, unlike Ruby's local variables. Attempting name <- "Bob" is a compile error.

F# requires the mutable keyword to opt in to mutability. Assignment to a mutable binding uses <- — not =. The = operator is always equality comparison in F#.

F#'s Hindley-Milner type inference deduces the type of every binding without annotations. Unlike Ruby's dynamic typing, these types are checked statically at compile time — number + greeting is a compile error, not a runtime one.

Type annotations use a colon after the identifier name. They are optional — the compiler infers types — but useful for documentation or when the compiler needs a hint. F# annotations always follow the name, never precede it as in C# or Java.

F# allows a let binding to shadow a previous one with the same name within a function scope. This creates a new immutable binding — the original is hidden, not mutated. Shadowing is common in F# pipeline code as an alternative to mutable variables.

F# has distinct numeric types: int (32-bit), int64 (64-bit, L suffix), float (64-bit double), and float32 (f suffix). Unlike Ruby, implicit coercion between them is not allowed — 1 + 1.0 is a type error.

F# uses conversion functions named after the target type: string, int, float, bool, etc. Unlike Ruby's .to_s method syntax, these are plain functions. Conversions that can fail (like int "abc") raise an exception at runtime.

F# uses &&, ||, and not (a function, not a prefix operator). Equality is =; inequality is <>. These match OCaml conventions and differ from C-family languages.

F# has a unit type (written as ()) representing "no meaningful value." Functions that perform side effects and return nothing have return type unit. It is a real type — not a null or nil — and signals to callers that the function is called for its effect.

F# tuples use parentheses with commas: (3, 4). They are destructured with let (x, y) = .... Tuples can hold mixed types: ("Alice", 30, true) has type string * int * bool. The * in the type is read as "and."

F# uses + for string concatenation, the same as Ruby. However, F# does not allow mixing + with non-string types — "Count: " + 5 is a compile error. Use string 5 to convert first, or use interpolation.

F# strings are .NET strings, so all .NET string methods are available. Properties like Length use no parentheses; methods like ToUpper() do. The naming convention is PascalCase (unlike Ruby's snake_case).

Split (from .NET) splits into a string array. String.concat joins a sequence of strings with a separator — the F# equivalent of Ruby's Array#join. Note that Split returns a .NET array (string[]), not an F# list.

F# triple-quoted strings (""") span multiple lines without escape sequences. Backslashes and quotes inside are treated literally. They are similar to Ruby heredocs but without the indentation-stripping that <<~ provides.

Trim() removes leading and trailing whitespace, equivalent to Ruby's strip. Substring(startIndex, length) extracts a portion — note that the second argument is a length, not an end index, unlike Ruby's slicing syntax.

F# lists use semicolons as element separators: [1; 2; 3]. This is the most common surprise for Rubyists. Writing [1, 2, 3] in F# creates a list of one element — a 3-tuple — not a three-element list. F# lists are immutable singly-linked lists.

The :: (cons) operator prepends a single element to a list. Unlike Ruby's +, cons is O(1) — it reuses the existing tail without copying it. F# lists are persistent: rest is unchanged after 1 :: rest.

List.map is F#'s equivalent of Ruby's map. The function argument comes first, then the list. Anonymous functions use fun parameter -> body syntax — F#'s equivalent of Ruby blocks. There are no method-chaining versions; use the pipe operator instead.

List.filter is the equivalent of Ruby's select. Note that = is the equality operator (not assignment), and % is modulo. F# has no equivalent of Ruby's Integer#even? — use explicit comparison instead.

List.fold is the equivalent of Ruby's inject/reduce. The argument order is: function, initial value, list. List.foldBack folds from the right. The function receives the accumulator first, then the current element.

F# arrays use [|...|] syntax with semicolons. Unlike F# lists, arrays are mutable and have O(1) indexed access. Element access uses .[index] or just [index] in newer F#. F# arrays are identical to .NET arrays.

F# sequences (seq { }) are lazy, like Ruby's Enumerator::Lazy. They compute elements on demand. Seq.take 5 evaluates only the first five elements. Most F# collection functions have Seq, List, and Array variants.

F# Map is an immutable ordered dictionary. It is built from a list of tuples using Map.ofList. Key-value pairs are tuples: (key, value) — not Ruby's key => value. Looking up a key that does not exist raises an exception; use Map.tryFind to get an Option instead.

F# uses elif (not elsif) and requires then after each condition. Unlike Ruby, F# if is an expression — it returns a value. Both branches must have the same type, otherwise the compiler reports a type error.

F# if/then/else is an expression that returns the value of whichever branch was taken. This replaces Ruby's ternary operator ?:. The else branch is required when the result is used — omitting it implies the value is unit.

F# for ... in ... do iterates over ranges and sequences. 1..5 is an inclusive range, identical to Ruby's 1..5. F# also has for i = 1 to 5 do for counted loops. The body is indented — F# uses significant whitespace.

F# while loops require mutable state. Idiomatic F# prefers recursion or sequence operations over imperative loops, but while is available. Note that <- is the mutation operator and there is no += shorthand in F#.

F# match uses | for each arm and -> to separate the pattern from the body. The _ wildcard matches anything, like Ruby's else in a case. Multiple patterns on one arm use |.

Match guards use when after a pattern to add a boolean condition. The bound name (n) is available in the guard expression. This is more explicit than Ruby's case/when with range patterns.

F# can match on tuples by destructuring them in the pattern. Each tuple element is bound to a name and can be used in guards or the body. Tuple matching in F# is the cleanest way to handle multi-dimensional case logic.

F# list patterns use :: to match the head and tail. [] matches empty, [x] matches a single-element list, and head :: tail matches any non-empty list. This is exhaustive — the compiler warns if a case is missing.

match is an expression in F# — it returns a value. All arms must return the same type. This allows match to appear in any expression context, including let bindings, function arguments, and inside pipelines.

F# function definitions use let. Parameters follow the function name separated by spaces — no parentheses, no commas, no return. The last expression is the return value. Function calls also use spaces: add 3 4, not add(3, 4).

Every F# function is automatically curried — calling it with fewer arguments than it expects returns a new function. multiply 2 returns a function int -> int. There is no .curry method — partial application is built into the language.

The >> operator composes two functions left-to-right: f >> g is equivalent to fun x -> g (f x). The << operator composes right-to-left. Function composition is a first-class idiom in F# alongside the pipe operator.

F# anonymous functions use fun parameter -> body. Multiple parameters: fun x y -> x + y. Unlike Ruby's blocks, F# lambdas are ordinary values — they can be stored in let bindings, passed to functions, and returned from functions.

F# requires the rec keyword to define a recursive function. This makes recursion explicit — a function without rec cannot call itself. The compiler can optimize tail-recursive functions to avoid stack overflow.

Functions are first-class values in F#. A function that accepts another function as a parameter is a higher-order function. The applyTwice function has inferred type ('a -> 'a) -> 'a -> 'a — it works for any type, not just integers.

The |> pipe operator passes the value on the left as the last argument to the function on the right. It reads top-to-bottom like Ruby's method chaining, but works with any function — not just methods on an object.

Without pipes, nested function calls must be read inside-out, which obscures the order of operations. Pipes make the data flow explicit and match the direction you read. This is the primary reason |> is so central to idiomatic F#.

The pipe operator works with any user-defined function, not just library functions. total |> addTax |> roundToCents is equivalent to roundToCents (addTax total). This style encourages designing functions that accept their primary data as the last argument.

>> composes two functions into a new function without a value — it is for defining reusable pipelines. |> applies functions to a specific value — it is for data transformation. Both produce the same result when given the same input; the choice depends on whether you need the composed function as a reusable value.

F# uses Some value and None instead of value-or-nil. Map.tryFind returns Some value on success and None on failure. The type system enforces handling both cases — Option<string> cannot be used where a string is expected.

Option.map applies a function to the value inside Some, leaving None unchanged. It is the typed equivalent of Ruby's &. safe navigation operator. The result is always an Option — Some "Alice" becomes Some 5.

Option.bind chains operations that each return an Option. If any step returns None, the chain short-circuits. This is the typed equivalent of Ruby's &.then { |x| ... } safe navigation chain, but tracked by the type system.

F# has a built-in Result<'T, 'E> type with Ok value and Error reason. It encodes expected failure in the type system, unlike Ruby's convention-based [:ok, value] tuples. The type forces callers to handle both outcomes.

Result.map applies a function to the value inside Ok, leaving Error unchanged. Combined with the pipe operator, it enables a chain of transformations that propagates the first error and continues on success.

F# records are immutable named data structures. Fields use FieldName: Type syntax. Record creation uses { FieldName = value; ... }. They are like Ruby's Struct but immutable by default and fully integrated with pattern matching and the type system.

The with keyword creates a copy of a record with specified fields changed. The original record is unchanged. This is the idiomatic way to "update" an immutable record — it is the F# equivalent of Ruby's Hash#merge for creating modified copies.

Records can be matched by field name. The { FieldName = binding } pattern extracts field values into local names. Partial matching is allowed — unmentioned fields are ignored. This is more structured than Ruby's hash pattern matching.

Records can nest other records. The with copy-update syntax handles nested updates, though it requires updating each level explicitly: { person with Address = { person.Address with City = "Berlin" } }. Lenses and optics libraries provide more ergonomic nested updates.

Discriminated unions (DUs) are F#'s algebraic sum types — a value is exactly one of a fixed set of cases. Each case is a named constructor. Pattern matching on a DU is exhaustive: the compiler warns if you miss a case. Ruby has no direct equivalent; symbols or classes are the closest approximation.

DU cases carry typed data. Circle of radius: float means the Circle case holds a float value named radius. Naming the fields makes construction and pattern matching self-documenting. This replaces Ruby's class hierarchy with a single concise type declaration.

Discriminated unions can be recursive — a Tree case can contain Tree values. Recursive DUs are the natural way to represent trees, linked lists, expression trees, and ASTs in F#. The rec keyword is needed for functions that recurse over them.

Option<'T> is itself a discriminated union built into F#. The 'T is a generic type parameter. Understanding DUs explains why Some and None behave as they do — they are just case constructors of an ordinary DU.

F# classes use a primary constructor directly in the type definition — constructor parameters are listed after the type name. member _.Method() defines an instance method; _ is the self reference (often written this). Constructor parameters are automatically in scope for all members.

F# properties are defined with member. Read-only properties use member _.Name = value. Mutable properties require explicit get() and set(value) accessors. F# code typically prefers immutable records over mutable classes.

F# uses inherit for class inheritance. To override a method, the base class must declare it abstract with a default implementation. Derived classes use override. F# enforces this distinction explicitly — unlike Ruby, where any method can be overridden.

F# interfaces use abstract member declarations. Implementing them requires an explicit interface InterfaceName with block. Casting to an interface uses :> (upcast). F# modules and functions often replace interfaces for simpler cases.

F# list comprehensions use [ for ... do ... yield ... ]. Multiple for loops create the cartesian product. <> is the not-equal operator. The yield keyword produces each element. This is more readable than Ruby's nested flat_map.

F# seq { } computation expressions create lazy sequences evaluated on demand, like Ruby's Enumerator. yield produces each value. Only as many elements as needed are computed — Seq.take 8 evaluates exactly 8 steps of the loop.

F# async { } computation expressions define asynchronous workflows. let! binds the result of another async operation without blocking. Async.RunSynchronously runs the workflow to completion. F#'s native async predates C#'s async/await and served as its inspiration.

Option.bind chains computations that return Option. When any step returns None, the entire chain short-circuits to None. This is equivalent to Ruby's safe navigation chain (&.then) but enforced by the type system at compile time.

F# modules are namespaces for functions and types. They are defined with module ModuleName = followed by indented definitions. Module functions are called as ModuleName.functionName arg, equivalent to Ruby's module methods defined with self..

open ModuleName makes all of a module's definitions available without qualification. This is like Ruby's include, but for functions rather than instance methods. Opening List, Seq, or Map is a common pattern in F# code that uses these modules heavily.

F# top-level let bindings and expressions outside any module act as the program's entry point — no main function needed. This is similar to Ruby's script mode. Larger F# programs organize code into modules and use [<EntryPoint>] for the main function.

F# uses try/with for exception handling. The :? operator performs a type test: :? ExceptionType as name is like Ruby's rescue ExceptionClass => variable. Multiple exception types can be matched with separate | arms.

try/finally ensures the cleanup block runs whether or not an exception occurred — the equivalent of Ruby's ensure. In F#, try/with and try/finally cannot be combined in one expression; nest them when both are needed.

raise throws an exception in F#. .NET exception types are used — System.ArgumentException, System.InvalidOperationException, etc. The |> ignore discards a return value when only the side effect (the potential exception) is needed.

Idiomatic F# prefers Result<'T, 'E> over exceptions for expected failure paths — parsing, validation, and lookups. Exceptions are reserved for truly unexpected failures. Using Result makes the function's failure modes explicit in its type signature and forces callers to handle them.