OCaml (.ml, .mli)

Overview

OCaml (Objective Caml) is a functional programming language with object-oriented features, emphasizing type safety, performance, and expressiveness. Developed in France by INRIA, OCaml combines the power of functional programming with practical features like imperative programming constructs and a sophisticated type system. It's widely used in systems programming, web development, and formal verification.

Technical Details

• File Extensions: .ml (implementation), .mli (interface)
• MIME Type: text/x-ocaml
• Category: Programming Language
• First Appeared: 1996
• Paradigm: Functional, imperative, object-oriented
• Platform: Cross-platform (native compilation)

Key Features

Strong Type System

• Static type checking with inference
• Algebraic data types and pattern matching
• Parametric polymorphism
• Module system with functors

Performance

• Native code compilation
• Efficient garbage collection
• Zero-cost abstractions
• Comparable to C/C++ performance

Safety and Expressiveness

• Memory safety without garbage collection overhead
• Immutability by default
• Exhaustive pattern matching
• Option types for null safety

Syntax Examples

Basic Functions and Types

(* Basic function definition *)
let square x = x * x

let add x y = x + y

(* Type annotations (optional due to inference) *)
let multiply (x : int) (y : int) : int = x * y

(* Recursive function *)
let rec factorial n =
  if n <= 1 then 1
  else n * factorial (n - 1)

(* Higher-order functions *)
let apply_twice f x = f (f x)

let double x = x * 2
let result = apply_twice double 3  (* result = 12 *)

Algebraic Data Types

(* Simple variant type *)
type color = Red | Green | Blue | RGB of int * int * int

(* Recursive data structure *)
type 'a tree = 
  | Empty 
  | Node of 'a * 'a tree * 'a tree

(* Pattern matching *)
let rec tree_size = function
  | Empty -> 0
  | Node (_, left, right) -> 1 + tree_size left + tree_size right

let color_to_string = function
  | Red -> "red"
  | Green -> "green"  
  | Blue -> "blue"
  | RGB (r, g, b) -> Printf.sprintf "rgb(%d,%d,%d)" r g b

List Processing

(* List operations *)
let numbers = [1; 2; 3; 4; 5]

let doubled = List.map (fun x -> x * 2) numbers

let sum = List.fold_left (+) 0 numbers

(* List comprehension style *)
let squares = List.init 10 (fun i -> i * i)

(* Pattern matching on lists *)
let rec sum_list = function
  | [] -> 0
  | head :: tail -> head + sum_list tail

Object-Oriented Programming

(* Class definition *)
class point x_init y_init =
  object (self)
    val mutable x = x_init
    val mutable y = y_init
    
    method get_x = x
    method get_y = y
    method move dx dy = x <- x + dx; y <- y + dy
    method distance other =
      let dx = x - other#get_x in
      let dy = y - other#get_y in
      sqrt (float (dx * dx + dy * dy))
  end

(* Using the class *)
let p1 = new point 0 0
let p2 = new point 3 4
let dist = p1#distance p2

Module System

Basic Modules

(* math.ml *)
let pi = 3.14159

let area_circle radius = pi *. radius *. radius

let area_rectangle width height = width *. height

(* math.mli - interface file *)
val pi : float
val area_circle : float -> float
val area_rectangle : float -> float -> float

Functors (Parameterized Modules)

(* Define a module type *)
module type Comparable = sig
  type t
  val compare : t -> t -> int
end

(* Functor that creates a Set module *)
module MakeSet (C : Comparable) = struct
  type elt = C.t
  type t = elt list
  
  let empty = []
  
  let rec add x = function
    | [] -> [x]
    | h :: t when C.compare x h < 0 -> x :: h :: t
    | h :: t when C.compare x h = 0 -> h :: t
    | h :: t -> h :: add x t
    
  let rec mem x = function
    | [] -> false
    | h :: t -> C.compare x h = 0 || mem x t
end

(* Using the functor *)
module IntSet = MakeSet(struct
  type t = int
  let compare = compare
end)

Development Tools

Compilers and Interpreters

• ocamlc: Bytecode compiler
• ocamlopt: Native code compiler
• ocaml: Interactive toplevel
• utop: Enhanced interactive toplevel

Build Systems

• dune: Modern build system
• ocamlfind: Package manager
• opam: Package manager
• Makefile: Traditional build approach

IDEs and Editors

• VSCode with OCaml Platform extension
• Emacs with Tuareg mode
• Vim with Merlin integration
• IntelliJ IDEA with OCaml plugin

Libraries and Frameworks

Web Development

• Dream: Modern web framework
• Opium: Sinatra-like web framework
• Eliom: Framework for client-server web applications
• Lwt: Cooperative threading library

Systems Programming

• Async: Concurrent programming library
• Mirage: Unikernel operating system
• Core: Alternative standard library
• Ctypes: Foreign function interface

Data Processing

• Owl: Scientific computing
• Batteries: Extended standard library
• Yojson: JSON parsing and generation
• Re: Regular expressions

Common Use Cases

Systems Programming

• Operating system components
• Compilers and interpreters
• Network servers
• Database systems

Web Development

• Backend services
• API development
• Static site generators
• Full-stack applications

Financial Technology

• Trading systems
• Risk analysis
• Quantitative modeling
• Blockchain implementations

Formal Verification

• Theorem proving
• Program verification
• Protocol analysis
• Safety-critical systems

File Organization

Project Structure

my_project/
├── dune-project          # Project configuration
├── lib/                  # Library code
│   ├── dune             # Build configuration
│   ├── mylib.ml         # Implementation
│   └── mylib.mli        # Interface
├── bin/                  # Executable code
│   ├── dune
│   └── main.ml
└── test/                 # Tests
    ├── dune
    └── test_mylib.ml

Dune Configuration

;; dune-project
(lang dune 2.9)
(package (name my_project))

;; lib/dune
(library
 (public_name my_project)
 (name mylib))

;; bin/dune
(executable
 (public_name my_project)
 (name main)
 (libraries mylib))

Error Handling

Option Types

(* Safe division using option types *)
let safe_divide x y =
  if y = 0 then None
  else Some (x / y)

let handle_division x y =
  match safe_divide x y with
  | None -> "Division by zero"
  | Some result -> string_of_int result

Result Types

type ('a, 'b) result = Ok of 'a | Error of 'b

let parse_int s =
  try Ok (int_of_string s)
  with Failure _ -> Error ("Invalid integer: " ^ s)

let process_input input =
  match parse_int input with
  | Ok n -> Printf.printf "Number: %d\n" n
  | Error msg -> Printf.printf "Error: %s\n" msg

Notable Applications

• Facebook: Flow type checker and Reason language
• Jane Street: Trading firm using OCaml extensively
• MirageOS: Unikernel operating system
• Coq: Theorem prover
• Docker: Container platform (originally)

Learning Resources

• "Real World OCaml" by Minsky, Madhavapeddy, and Hickey
• "OCaml from the Very Beginning" by John Whitington
• Official OCaml manual and tutorials
• "More OCaml: Algorithms, Methods & Diversions"
• OCaml.org community resources

OCaml continues to be an excellent choice for developers who want the safety and expressiveness of functional programming combined with the performance and practical features needed for real-world applications.