Elm.CodeCompared.To/OCaml

You are meeting the language your language came from: Elm's syntax family — let, whitespace application, arrow types — is OCaml's, via Haskell and F#. The let () = idiom pattern-matches the unit result of print_endline, quietly asserting the expression returns () — a tiny taste of how deeply matching runs here.

Hindley–Milner inference has been running this show since 1978 — answer needs no annotation in either language. Printf.printf's format string is type-checked at compile time: %d demands an integer, %s a string, and a mismatch is a compile error, not a runtime surprise.

Each let count = count + 1 defines a new immutable binding whose initializer sees the previous one — no mutation happens, but the name is reused. Elm rejected shadowing to keep every name unambiguous; OCaml embraces it as pipeline-style rebinding. Watch for it when reading OCaml: the count on line three is not the count on line one.

The ! prefix dereferences (nothing to do with boolean not, which is not), and := stores. Functional style remains the default — a fold would be more idiomatic here — but OCaml treats imperative code as a first-class tool rather than a sin, which is the big philosophical divergence from Elm.

Integer / truncates — it is Elm's // — and there is no implicit conversion in either language, so float_of_int does explicitly what Elm's two division operators sidestep. The dotted operators are the price OCaml pays for full inference without type classes: the operator itself pins the type.

Like Elm, OCaml never coerces a number into a string — you convert with string_of_int or reach for Printf, whose type-checked format string is the closest thing to interpolation. Elm's ++ habits transfer directly; only the symbol changes.

Same module-of-functions organization — String.length is even spelled identically. The _ascii suffix on uppercase_ascii is honest labeling: the standard library's case functions only handle ASCII, and real Unicode work uses an external library, where Elm's String.toUpper is Unicode-aware out of the box.

Identical shape, identical semantics, identical inferred type — int -> int -> int. Unlike ReScript (which abandoned currying for JS-friendly output), OCaml keeps the full ML discipline, so an Elm developer's partial-application instincts work unmodified. Naming flips to snake_case by convention.

Elm's \number -> is fun number -> — F# kept the same keyword. Notice List.map takes the function first and the list last, curried, exactly as in Elm; the partial application Printf.printf "%d " handed to List.iter shows the style paying off.

Data-last currying is what makes this work: each stage is a partially applied function waiting for the list. Dialect notes: equality is a single =, modulo is the infix mod keyword, and Elm's List.sum is spelled as a fold — List.fold_left (+) 0, passing the operator itself.

The rec keyword is OCaml's own rule (F# and ReScript inherited it): without it, the body's factorial would refer to some earlier binding rather than the one being defined — which is precisely what makes deliberate shadowing possible. Elm, having banned shadowing, could make every definition recursive by default.

F# inherited both the semicolons and the trap from here: [ 1, 2, 3 ] type-checks as [(1, 2, 3)], a single-element list holding a triple. The cons operator :: is Elm's own, unchanged, and works in patterns the same way.

The vocabulary maps almost one to one: List.map, List.filter, List.length, List.rev; Elm's List.foldl is List.fold_left. Both are the same immutable singly-linked list underneath — cheap to prepend, walked to append.

Indexing is numbers.(0) and in-place update is <- — no new array is allocated, which Elm simply cannot express. F#'s [| |] syntax came from here. Idiomatic OCaml uses lists for everyday data and arrays when performance or fixed-size mutation matters.

The type is written int * string — the product-type star Elm replaced with parentheses. Destructuring in a let works as in Elm, and fst/snd are Tuple.first/Tuple.second.

Field punning — let { name; age } = person — destructures a record by field name, something Elm also allows in function arguments. Dot access person.name works too. The literal finds its type by its field names, so the declaration usually sits quietly at the top of the file.

This is the original — F# copied { person with age = 37 } verbatim, and Elm's { person | age = 37 } is the same construct respelled. A new record shares the unchanged fields; the original is untouched, as the second print shows.

A multi-value payload is one tuple (Rectangle (3.0, 4.0)) rather than Elm's curried constructor arguments — F# kept that too. Exhaustiveness checking behaves like Elm's: leave out a constructor and the compiler tells you which one.

Postfix type application reads like English backwards from Elm: int list, string option, 'value tree. It is the one piece of ML syntax Elm's designers reversed. The tick on 'value is the traditional type-variable marker Elm dropped.

Everything transfers: empty-list and exact-length patterns, cons, wildcards, exhaustiveness warnings naming the missing cases. OCaml marks branches with a leading | where Elm uses indentation — this is the construct case … of was modeled on.

The when guard is the ancestor of F#'s, with the same trade Elm opted out of: arbitrary conditions on a pattern, at the cost of the compiler no longer proving the guarded cases exhaustive — hence the mandatory final wildcard.

Maybe.map is Option.map, Maybe.withDefault is Option.value ~default:… (that tilde marks a labeled argument, an OCaml feature Elm never had), and the _opt suffix on List.find_opt signals the safe variant — because, as the exceptions section shows, the unsuffixed List.find throws.

OCaml's ('ok, 'error) result puts the success type first where Elm writes Result error value, and spells Err as Error. Result.map and Result.bind chain exactly like Result.map/Result.andThen.

The exception pattern inside match (an OCaml 4.02 gem) handles the raise in the same expression that handles success. This is the deepest cultural difference from Elm: OCaml's standard library predates the option-everywhere consensus, so you must know which functions throw. Modern OCaml style leans toward the _opt variants — an Elm developer's instincts pointing the right way.

The loop body must return () — it exists purely for side effects, which is why Elm (having none) never needed the construct. In practice OCaml programmers still reach for List.map and folds first; the loop is there for the cases where an index and mutation genuinely read better.

This inline module … = struct … end barely hints at the system: signatures hide implementation details the way Elm's exposing lists do, and functors — functions from modules to modules — power things like Map.Make, generating a whole map implementation from a comparison module. It is OCaml's most celebrated feature and has no Elm counterpart at all.