OCaml facts for kids

Quick facts for kids
OCaml

Paradigms	Multi-paradigm: functional, imperative, modular, object-oriented
Family	ML: Caml
Designed by	Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez
Developer	Inria
First appeared	1996; 29 years ago (1996)
Stable release	5.3.0  / 8 January 2025; 7 months ago (8 January 2025)
Typing discipline	Inferred, static, strong, structural
Implementation language	OCaml, C
Platform	IA-32, x86-64, Power, SPARC, ARM 32-64, RISC-V
OS	Cross-platform: Linux, Unix, macOS, Windows
License	LGPLv2.1
Filename extensions	.ml, .mli
Influenced by
C, Caml, Modula-3, Pascal, Standard ML
Influenced
ATS, Rocq (previously known as Coq), Elm, F#, F*, Haxe, Opa, Rust, Scala, Gleam

OCaml (pronounced "oh-KAM-əl") is a powerful programming language that helps people create computer programs. It's a "general-purpose" language, meaning you can use it for many different kinds of projects. OCaml was first made in 1996 by a team of smart people including Xavier Leroy.

OCaml is special because it combines different ways of programming, like functional and object-oriented styles. It comes with many tools, like a way to run code step-by-step (an interpreter) and a tool to turn your code into programs that run very fast (a compiler). OCaml is used in many areas, from making sure software is correct to building websites and financial tools. It's also a free and open-source project, managed by a group in France called Inria.

How OCaml Works

OCaml is known for its smart "type system." Think of types as labels that tell the computer what kind of data something is (like a number, text, or a list).

Understanding Types in OCaml

OCaml has a "static type system." This means it checks for type mistakes before your program even runs. This helps prevent many errors that might crash a program later. What's cool is that OCaml can often figure out the types on its own, so you don't always have to tell it. This makes writing code faster and easier.

Why OCaml is Fast

OCaml is designed to be very fast. Because it checks types early, it doesn't need to do as many checks while the program is running. This helps it run quickly. OCaml also has a special "optimizing compiler" that makes your code super efficient. Some experts say OCaml can run almost as fast as programs written in C, which is known for its speed!

The Story of OCaml

OCaml has an interesting history, growing from earlier programming ideas.

The OCaml development team receiving an award at Symposium on Principles of Programming Languages (POPL) 2024

Early Ideas: ML

The journey to OCaml started in the 1970s and 1980s with a computer scientist named Robin Milner. He was working on "theorem provers," which are programs that check if mathematical proofs are correct. Milner created a language called ML (Meta Language) to help build these provers. ML was designed to make sure that only valid proofs could be created.

Later, in the 1980s, researchers in France became interested in ML. They found new ways to make ML run faster and more efficiently.

The First Caml Versions

The first version of Caml was created in 1987 by a team at Inria. It was improved over the years. In 1990-1991, Xavier Leroy made a new version called Caml Light. This version was smaller and could run on desktop computers. It also had a "garbage collector" to help manage computer memory.

In 1995, Xavier Leroy released Caml Special Light. This was a big step because it added a new compiler that made programs run much faster, similar to languages like C++. It also had a better "module system" to help organize larger programs.

The Birth of Objective Caml (OCaml)

In 1996, more features were added to Caml Special Light, especially for object-oriented style. This new version was called Objective Caml. It was renamed to OCaml in 2011. This version made it easier to build complex programs in a safe way.

OCaml has continued to grow and improve. In 2022, a major update (OCaml 5.0.0) changed how the language works internally, making it better for programs that need to do many things at once (like parallel computing). In 2023, the OCaml compiler even won a special award for programming language software!

Cool Things OCaml Can Do

OCaml has many features that make it a powerful and flexible language.

Key Features

• Static Type System: Checks for errors before running.
• Type Inference: Automatically figures out data types.
• Pattern Matching: A neat way to check data and do different things based on what it looks like.
• Garbage Collection: Automatically cleans up computer memory.
• Connecting to C: OCaml can easily work with code written in the C language. This is useful because many existing tools are in C.

OCaml also comes with tools to help you build programs, like:

• Tools for analyzing text and code (ocamllex and ocamlyacc).
• A debugger to help you find and fix mistakes in your code.
• A documentation generator to create guides for your programs.
• A profiler to see how fast different parts of your program run.
• Many useful libraries (collections of ready-to-use code).

OCaml programs can run on many different computer systems, including Linux, Windows, and macOS.

OCaml Code Examples

Let's look at some simple examples of OCaml code. You can try these in the OCaml "top-level" or "REPL," which is like an interactive calculator for OCaml.

To start it, you type:

$ ocaml
     Objective Caml version 3.09.0
#

Then you can type code at the "#" prompt.

Simple Math

# 1 + 2 * 3;;
- : int = 7

OCaml figures out that the answer is an "int" (integer) and gives you "7".

Hello World!

This is a classic first program. It just prints "Hello World!" to the screen.

print_endline "Hello World!"

You can save this as a file (like `hello.ml`) and run it:

$ ocaml hello.ml

Or compile it into a program you can run later:

$ ocamlc hello.ml -o hello
$ ./hello
Hello World!
$

Handling Missing Values (Option Type)

Sometimes a value might not be there. OCaml has an `option` type to handle this. It can be `Some` value (meaning it's there) or `None` (meaning it's not).

# Some 42;;
- : int option = Some 42
# None;;
- : 'a option = None

Here's a function that takes an `option` and turns it into a string:

let extract o =
  match o with
  | Some i -> string_of_int i
  | None -> "";;

# extract (Some 42);;
- : string = "42"
# extract None;;
- : string = ""

Adding Numbers in a List

Lists are very common in OCaml. Here's a function to add up all the numbers in a list:

let rec sum integers =                   (* Keyword rec means 'recursive'. *)
  match integers with
  | [] -> 0                              (* If the list is empty, the sum is 0. *)
  | first :: rest -> first + sum rest;;  (* Otherwise, add the first number to the sum of the rest. *)

  # sum [1;2;3;4;5];;
  - : int = 15

There are also shorter ways to write this using built-in OCaml tools:

let sum =
  List.fold_left (+) 0

Sorting a List (Quicksort)

OCaml is great for writing sorting algorithms. This code sorts a list of items:

 let rec qsort = function
   | [] -> []
   | pivot :: rest ->
     let is_less x = x < pivot in
     let left, right = List.partition is_less rest in
     qsort left @ [pivot] @ qsort right

The Birthday Problem

This program solves a fun math puzzle: how many people do you need in a room for there to be a 50% chance that at least two people share a birthday?

let year_size = 365.

let rec birthday_paradox prob people =
  let prob = (year_size -. float people) /. year_size *. prob  in
  if prob < 0.5 then
    Printf.printf "answer = %d\n" (people+1)
  else
    birthday_paradox prob (people+1)
;;

birthday_paradox 1.0 1

The answer is 23 people!

Big Numbers (Factorial)

OCaml has libraries to handle very large numbers, much bigger than what a normal calculator can manage. The factorial function (like 5! = 5 * 4 * 3 * 2 * 1) grows very fast.

# #use "topfind";;
# #require "num";;
# open Num;;

Then you can define factorial:

# let rec fact n =
    if n =/ Int 0 then Int 1 else n */ fact(n -/ Int 1);;
val fact : Num.num -> Num.num = <fun>

And calculate huge factorials, like 120!:

# string_of_num (fact (Int 120));;
- : string =
"6689502913449127057588118054090372586752746333138029810295671352301633
55724496298936687416527198498130815763789321409055253440858940812185989
8481114389650005964960521256960000000000000000000000000000"

Drawing Graphics (Triangle)

OCaml can also be used to create graphics, like a spinning triangle using OpenGL:

let () =
  ignore (Glut.init Sys.argv);
  Glut.initDisplayMode ~double_buffer:true ();
  ignore (Glut.createWindow ~title:"OpenGL Demo");
  let angle t = 10. *. t *. t in
  let render () =
    GlClear.clear [ `color ];
    GlMat.load_identity ();
    GlMat.rotate ~angle: (angle (Sys.time ())) ~z:1. ();
    GlDraw.begins `triangles;
    List.iter GlDraw.vertex2 [-1., -1.; 0., 1.; 1., -1.];
    GlDraw.ends ();
    Glut.swapBuffers () in
  GlMat.mode `modelview;
  Glut.displayFunc ~cb:render;
  Glut.idleFunc ~cb:(Some Glut.postRedisplay);
  Glut.mainLoop ()

This program can be compiled and run to show a simple animation.

Fibonacci Sequence

The Fibonacci sequence is a series of numbers where each number is the sum of the two before it (0, 1, 1, 2, 3, 5, 8...). This OCaml code calculates the Nth Fibonacci number:

let fib n =
  let rec fib_aux m a b =
    match m with
    | 0 -> a
    | _ -> fib_aux (m - 1) b (a + b)
  in fib_aux n 0 1

Functions That Use Other Functions

OCaml lets you write "higher-order functions," which are functions that can take other functions as input or give functions back as output. For example, `twice` takes a function `f` and returns a new function that applies `f` two times:

let twice (f : 'a -> 'a) = fun (x : 'a) -> f (f x);;
let inc (x : int) : int = x + 1;;
let add2 = twice inc;;
let inc_str (x : string) : string = x ^ " " ^ x;;
let add_str = twice(inc_str);;

  # add2 98;;
  - : int = 100
  # add_str "Test";;
  - : string = "Test Test Test Test"

You can even apply `twice` to itself!

  # let fourtimes f = (twice twice) f;;
  val fourtimes : ('a -> 'a) -> 'a -> 'a = <fun>
  # let add4 = fourtimes inc;;
  val add4 : int -> int = <fun>
  # add4 98;;
  - : int = 102

Languages Based on OCaml

OCaml has inspired other programming languages:

• F# is a language for the .NET platform that is based on OCaml.
• Reason is another way to write OCaml code, created by Facebook. It can turn OCaml code into native programs or even JavaScript for web browsers.

Software Made with OCaml

Many real-world programs and tools use OCaml:

• Ahrefs, a tool for improving websites for search engines.
• Astrée, a tool that checks software for errors.
• Rocq (formerly Coq), a system for checking formal proofs.
• The web version of Facebook Messenger.
• Flow, a tool from Facebook that checks JavaScript code for types.
• Ocsigen, a framework for building web and mobile apps.
• Owl Scientific Computing, a system for science and engineering calculations.
• The compiler for the Hack language (used at Facebook).
• The compiler for the Haxe language.
• Infer, another static checker from Facebook for Java, C, and C++.
• MirageOS, a special kind of operating system written entirely in OCaml.
• MLdonkey, a file-sharing application.
• The Rust compiler was first written in OCaml.
• Tezos, a platform for smart contracts (like digital agreements).
• Unison, a program to keep files synchronized between different folders.
• The official interpreter for WebAssembly, a low-level code format for web browsers.
• Xen Cloud Platform (XCP), a virtualization solution.

Who Uses OCaml?

Many companies and universities use OCaml:

• Bloomberg L.P., a financial company, uses OCaml and created a tool called BuckleScript.
• Citrix Systems, a tech company, uses OCaml in its XenServer product.
• Facebook has developed many tools in OCaml, like Flow, Hack, and Infer.
• Jane Street Capital, a trading firm, uses OCaml as its main programming language.
• Docker, a company known for its software containers, uses OCaml in its desktop apps.

OCaml is also taught in many computer science programs at universities and colleges around the world. You can find a list of these on the ocaml.org website.