Ruby.CodeCompared.To/OCaml

print_endline prints a string followed by a newline — the direct equivalent of Ruby's puts. The let () = ... pattern is OCaml's way of executing a side-effecting expression at the top level; the unit value () discards the result.

The semicolon ; sequences expressions in OCaml: it evaluates the left side (which must return unit), discards the result, and continues with the right side. This is the OCaml equivalent of Ruby's newline-separated statements.

print_string writes without a trailing newline, like Ruby's print. print_endline appends a newline, like Ruby's puts. OCaml also provides print_newline () to emit a newline on its own.

Printf.printf works like C's printf — format string followed by arguments. Unlike Ruby's comma-separated arguments, OCaml uses curried function application: each argument is space-separated. The format string is type-checked at compile time.

OCaml has separate functions for printing each type: print_int, print_float, print_string, print_bool. Using Printf.printf with format specifiers is more flexible. The %g specifier removes trailing zeros from floats.

In OCaml, let creates an immutable binding — it cannot be reassigned. This is different from Ruby's variables, which can be freely reassigned. Attempting to write number = 99 after the binding is a compile error.

Mutation in OCaml is explicit: ref allocates a mutable cell, ! dereferences it (reads the value), and := assigns a new value. This contrasts with Ruby, where all variables are mutable by default.

let ... in ... creates a locally scoped binding that only exists within the in expression. Nested let...in blocks read top-to-bottom, similar to a Ruby begin...end block, but each name is truly local.

A let binding can shadow an earlier one with the same name. This looks like reassignment but is not — the original binding still exists; the new one simply takes precedence in the inner scope. The right-hand side of the second let still refers to the original value.

OCaml uses Hindley-Milner type inference: every value has a precise static type, but you rarely need to write it. The compiler deduces int, string, and bool automatically. The %b format specifier prints booleans as true or false.

OCaml's unit type has exactly one value: (). It plays the role Ruby's nil plays for side-effecting methods — it signals "this returns no meaningful value." Functions that take no arguments accept (), and let () = ... at the top level executes a side effect and discards the result.

OCaml has separate arithmetic operators for integers and floats: + - * / for int, and +. -. *. /. for float. Mixing them without explicit conversion is a compile error — unlike Ruby, where numeric types interoperate freely.

OCaml uses explicit conversion functions: int_of_float truncates (no rounding), float_of_int, string_of_int, int_of_string. Ruby's .to_i and .to_f methods are instance methods on the value; OCaml's conversions are plain functions.

In OCaml, = is structural equality (like Ruby's ==) and <> is inequality (like !=). Boolean negation is the function not rather than a ! operator. Physical (reference) equality uses ==.

OCaml has a distinct char type for single characters, written with single quotes. Char.code returns the ASCII code (equivalent to Ruby's .ord), and Char.chr converts back. Characters and single-character strings are different types.

Type annotations in OCaml are written with : type after the name. They are optional — the compiler infers them — but useful for documentation and to trigger clearer error messages. The return type annotation goes after the last parameter, before =.

OCaml uses the ^ operator for string concatenation. Ruby uses +. The ^ operator creates a new string — OCaml strings are immutable by default (though technically they are byte arrays that can be mutated with Bytes).

String.length returns the byte length (not character count for multi-byte encodings). The _ascii suffix on String.uppercase_ascii and String.lowercase_ascii indicates that only ASCII letters are transformed — full Unicode case conversion requires a third-party library.

String.trim removes leading and trailing whitespace. String.sub takes a string, a start index, and a length — equivalent to Ruby's String#[] with two arguments. Attempting to access out-of-bounds bytes raises Invalid_argument.

OCaml has no string interpolation syntax. Instead, Printf.sprintf builds a formatted string and returns it — analogous to Ruby's format or sprintf. The format string is type-checked at compile time, so passing the wrong type is a compile error, not a runtime error.

String.split_on_char splits on a single char, returning a string list. Ruby's split accepts a string or regex; OCaml's stdlib split accepts only a single character. For regex-based splitting, the Re or Str libraries are needed.

OCaml lists use semicolons as separators inside square brackets — not commas. A comma creates a tuple, so [1, 2] is a one-element list containing the pair (1, 2). Lists are immutable singly-linked lists; all elements must share the same type.

The :: cons operator prepends an element to a list in O(1). It is the same operator used in pattern matching (head :: tail). OCaml lists are immutable singly-linked lists, so prepending is efficient, but appending (@) requires copying the left list.

List.map applies a function to every element and returns a new list — identical in behavior to Ruby's Enumerable#map. In OCaml, the function comes first and the list second; in Ruby, the list is the receiver and the block is the argument.

List.filter is the OCaml equivalent of Ruby's select/filter. Note that OCaml uses mod for the remainder operator (Ruby uses %), and = for equality comparison (Ruby uses ==).

List.fold_left is OCaml's left fold — equivalent to Ruby's reduce or inject. The accumulator comes first in the function arguments. There is also List.fold_right, which processes from right to left (and has reversed argument order).

OCaml arrays use [| ... |] delimiters and element access with .(index). Unlike lists, arrays are mutable: items.(1) <- value updates in place. Arrays have O(1) random access; lists have O(n). The Array module provides map, filter, fold, and other operations.

Tuples are fixed-length, heterogeneous collections — a pair, triple, etc. They are written with parentheses and commas. The type of (42, "hello") is int * string — the * in the type mirrors Cartesian product notation. Pattern matching destructures tuples inline.

OCaml's Hashtbl module provides mutable hash tables. Hashtbl.create takes an initial capacity hint. Hashtbl.find raises Not_found if the key is absent — use Hashtbl.find_opt for a safe version that returns an option.

In OCaml, if/else is an expression that returns a value — the same as Ruby's if. Both branches must return the same type; the compiler enforces this. OCaml uses else if (two keywords) rather than Ruby's elsif.

An if without else is valid only when the then branch returns unit (a side effect with no value). If the then branch returned, say, a string, the compiler would require an else branch returning the same type.

OCaml's for loop iterates over an integer range (inclusive on both ends) with for variable = start to finish do ... done. The loop variable is immutable inside the body. Use downto instead of to to count downward.

OCaml's while loop requires explicit mutation via a ref cell because all let bindings are immutable. The ! operator reads the current value and := writes a new one. Idiomatic OCaml prefers recursion or higher-order functions over while loops.

List.iter applies a function to each element for its side effects, discarding the results — equivalent to Ruby's each. String.capitalize_ascii uppercases only the first character. For most iteration over lists, List.iter or List.map replaces explicit loops.

match is OCaml's equivalent of Ruby's case/when, but it is an expression that returns a value and is checked for exhaustiveness at compile time. The _ wildcard catches any remaining cases. Each arm is written with | pattern -> expression.

String patterns in match use structural equality. The wildcard _ matches any value without binding it to a name. If you want to use the matched value in the arm body, use a variable name instead of _.

Because match is an expression, its result can be assigned directly to a binding. This is idiomatic OCaml — unlike Ruby's case which is also an expression but is less commonly used that way.

Tuples can be matched directly — specific values and wildcards can be mixed freely within a single tuple pattern. The compiler checks all combinations are covered. This replaces a cascade of if/elsif conditions with something the compiler can verify is complete.

Lists are matched with [] for the empty list and head :: tail to destructure the first element from the remainder. This mirrors how cons cells are constructed. Recursive functions on lists typically match these two cases.

A when clause adds a guard condition to a pattern arm — the arm only matches if both the pattern and the guard are true. Guard variables are bound from the pattern. If no arm matches (e.g., all guards fail), OCaml raises Match_failure.

Functions in OCaml are defined with let name param1 param2 = body. There are no parentheses around parameters in the definition. Calling a function uses space-separated arguments: add 3 4, not add(3, 4). Parentheses are only needed for grouping.

Every OCaml function is automatically curried — applying it to fewer arguments than it expects returns a new function. There is no need for .curry as in Ruby. Partial application is the natural result of calling a multi-argument function with only some of its arguments.

Anonymous functions are written with fun parameter -> body. They work like Ruby's lambdas or blocks. Multiple parameters: fun x y -> x + y. In OCaml, named functions (let f x = ...) are syntactic sugar for binding a fun expression.

OCaml requires the rec keyword to allow a function to call itself — without it, the name is not in scope inside the body. Ruby methods are always recursive implicitly. Use let rec ... and ... to define mutually recursive functions.

Functions are first-class values in OCaml: they can be passed as arguments, returned from functions, and stored in data structures. This is the same as Ruby's procs and lambdas, but with static types — the type of apply is inferred as 'a -> ('a -> 'b) -> 'b.

The |> pipe operator (available since OCaml 4.01) threads a value through a sequence of functions: value |> f is f value. It reads left-to-right, like Ruby's method chaining. The operator that inspired F#'s |> and Elixir's |> came from OCaml.

Labeled arguments use a ~label: prefix. Optional arguments use ?(label = default). A trailing () parameter is conventional to force evaluation when optional arguments are present. Labeled arguments can be passed in any order, just like Ruby's keyword arguments.

OCaml has no dedicated composition operator (Haskell's . or F#'s >>), but the pipe operator |> achieves composition inline. For point-free composition, you can write let compose f g x = x |> f |> g.

OCaml's option type makes absence explicit at the type level: a value is either None (absent) or Some value (present). Unlike Ruby's nil, you cannot accidentally call a method on None — the compiler forces you to handle both cases.

Matching on option is exhaustive — the compiler warns if either None or Some is unhandled. The Some number pattern both tests for presence and binds the contained value in one step, eliminating any need for a null check followed by an unwrap.

Option.map applies a function to the value inside Some, returning None unchanged — analogous to Ruby's safe navigation operator &.. If the option is None, the function is never called.

Option.bind opt f applies f to the value inside Some, returning None unchanged — the monadic bind for option. Unlike Option.map, the function f itself returns an option, so the result is not wrapped in an extra Some. Equivalent to Ruby's &.then { ... } when the block can return nil.

Option.value extracts the value from Some, returning the ~default if the option is None. This is the OCaml equivalent of Ruby's || idiom for default values. Option.get extracts without a default and raises Invalid_argument on None.

A variant type (also called a sum type or algebraic data type) defines a closed set of possibilities. Unlike Ruby's symbols, each constructor is a proper typed value — the compiler enforces exhaustive matching and catches typos at compile time.

Variant constructors can carry data — Circle of float bundles a float with the tag. Multi-field constructors use tuples: Rectangle of float * float. Pattern matching destructures both the tag and the data in one step, and the compiler checks all cases are covered.

Variants can be self-referential: tree contains tree values. The rec keyword is required on the matching function because it calls itself. Recursive data types paired with recursive functions over them are a fundamental OCaml idiom.

The 'a prefix is a type parameter — it makes the variant generic over any type. This is how OCaml's built-in option is defined: type 'a option = None | Some of 'a. A string maybe and an int maybe are different types, checked at compile time.

Variants make domain modeling precise: a token can only be one of the defined constructors, and the compiler enforces that every case is handled. Using an ADT instead of symbols or strings eliminates whole categories of runtime errors.

OCaml records are immutable typed structs with named fields. Field access uses dot notation, like Ruby's struct accessors. Record fields are separated by semicolons in both the type definition and the construction expression. All fields must be provided at construction time.

The { record with field = new_value } syntax creates a new record that copies all fields from the original except those explicitly listed. The original is unchanged. This is the OCaml equivalent of Ruby's Hash#merge or a struct's with pattern in other languages.

Records can be destructured in match patterns: { name; age } binds both fields simultaneously. A when guard can then test the bound values. This combines field access, binding, and conditional logic into a single readable pattern.

Individual record fields can be marked mutable, allowing in-place mutation with <-. By default all fields are immutable. This opt-in mutability is different from Ruby, where all instance variables are mutable by default.

OCaml's standard library is organized into modules accessed with Module.function. Unlike Ruby, where methods belong to objects, OCaml functions are free-standing values inside module namespaces. The top-level Stdlib module is opened automatically.

open Module brings all of a module's names into scope for the rest of the file — similar to Ruby's include at the module level. sqrt comes from Stdlib, which is always open. Use open sparingly to avoid name shadowing confusion.

A module is defined with module Name = struct ... end. The body contains the same let bindings, type definitions, and other modules that appear at the top level. OCaml modules are first-class and significantly more powerful than Ruby modules — they support functors (higher-order modules) and signatures (interfaces).

let open Module in expr opens a module only for the scope of expr, avoiding global namespace pollution. This is useful when writing a block of code that heavily uses one module. An alternative syntax is Module.(expr) for single expressions.

try ... with pattern -> handler catches exceptions. int_of_string raises Failure "int_of_string" on invalid input (use int_of_string_opt for a safe version). Exception patterns use the same syntax as variant patterns.

Custom exceptions are declared with exception Name of payload_type — they are actually variant constructors of the built-in exn type. The raise function works like Ruby's raise. Exceptions can carry data, just like variant constructors.

OCaml's result type is type ('a, 'e) result = Ok of 'a | Error of 'e. It models operations that can fail without using exceptions. The caller is forced to handle both outcomes. This approach, inspired by OCaml, was later adopted by Rust and other languages.

Result.map applies a function to the value inside Ok, leaving Error unchanged — analogous to Option.map. There is also Result.bind for chaining functions that return result. These combinators allow building error-handling pipelines without nested match expressions.

failwith message is shorthand for raise (Failure message) — it raises the standard Failure exception. The type annotation ([] : int list) is needed here only because the empty list's element type cannot be inferred from context. assert false is another common idiom for unreachable branches.