OCaml

Handsome Rank #12 — 44/60 points

Φ Geometry 7

Ω Elegance 9

Λ Clarity 8

Ψ Happiness 5

Γ Habitability 7

Σ Integrity 8

B Total 44

Character

The quiet genius in the corner who invented half of modern type theory and never got credit. OCaml's type system is a masterpiece; its ecosystem is an archaeology dig.

Dimension Analysis

Φ Aesthetic Geometry 7/10

Pattern matching, let bindings, and module signatures create a structured visual feel. Clean but not striking, the syntax is functional without being visually adventurous.

Ω Mathematical Elegance 9/10

MetaLanguage-family heritage gives OCaml one of the most expressive type systems in existence. GADTs, functors, and first-class modules enable algorithm expression that approaches mathematical proof. Type theory pioneers use OCaml for a reason.

Λ Linguistic Clarity 8/10

The |> operator, descriptive module paths, and pattern matching make OCaml code readable to anyone familiar with ML conventions. The language communicates structure and intent through types rather than comments.

Ψ Practitioner Happiness 5/10

A small community with niche adoption. Tooling has improved dramatically (opam, dune, Merlin), but the ecosystem remains thin compared to mainstream languages. Practitioners love it deeply, but they are few.

Γ Organic Habitability 7/10

Strong types and module boundaries help code age well. The functors system enables reusable, extensible abstractions. Docked because the ecosystem's small size means fewer established patterns for common problems.

Σ Conceptual Integrity 8/10

OCaml has always known what it is: a practical functional language with an exceptional type system. The design is focused and coherent, types as the organizing principle, everything else in service of that.

How are these scores calculated? Read the methodology

Signature Code

Recursive pattern match

type 'a tree =
  | Leaf
  | Node of 'a tree * 'a * 'a tree

let rec fold f acc = function
  | Leaf -> acc
  | Node (left, value, right) ->
    let acc = fold f acc left in
    let acc = f acc value in
    fold f acc right

Compare OCaml

vs Lisp vs Go vs Scala vs Python vs Haskell