View source for OCaml

{{Short description|Programming language}}
{{Infobox programming language
 | name                   = OCaml
 | logo                   = OCaml Logo.svg
 | logo caption           = 
 | screenshot             = 
 | screenshot caption     = 
 | paradigm               = [[Programming paradigm#Multi-paradigm|Multi-paradigm]]: [[Functional programming|functional]], [[Imperative programming|imperative]], [[Modular programming|modular]],<ref>{{cite web|title=Modules|url=https://ocaml.org/learn/tutorials/modules.html|access-date=22 February 2020}}</ref> [[Object-oriented programming|object-oriented]]
 | family = [[ML (programming language)|ML]]
 | scope                  =
 | released               = {{Start date and age|1996}}<ref>{{cite web|url=https://sympa.inria.fr/sympa/arc/caml-list/1996-05/msg00003.html|title=Objective Caml 1.00|author=[[Biography:Xavier Leroy|Xavier Leroy]]|year=1996|publisher=caml-list mailing list}}</ref>
 | designer               = [[Biography:Xavier Leroy|Xavier Leroy]], Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez
 | developer              = Inria

 | latest release version = {{wikidata|property|edit|reference|P548=Q2804309|P348}}
 | latest release date    = {{start date and age|{{wikidata|qualifier|P548=Q2804309|P348|P577}}}}
 | latest preview version = 
 | latest preview date    = <!-- {{Start date and age|YYYY|MM|DD}} -->
 | typing                 = [[Type inference|Inferred]], static, [[Strong and weak typing|strong]], structural
 | implementations        = 
 | influenced by          = [[C (programming language)|C]], [[Caml]], [[Modula-3]], [[Pascal (programming language)|Pascal]], [[Standard ML]]
 | influenced             = [[ATS (programming language)|ATS]], [[Software:Coq|Coq]], [[Elm (programming language)|Elm]], [[F Sharp (programming language)|F#]], [[F* (programming language)|F*]], [[Haxe]], [[Opa (programming language)|Opa]], [[Rust (programming language)|Rust]],<ref>{{Cite web |url=https://doc.rust-lang.org/reference/influences.html |title=Influences - The Rust Reference |website=The Rust Reference |access-date=2023-12-31}}</ref> [[Scala (programming language)|Scala]]
 | programming language   = OCaml, [[C (programming language)|C]]
 | platform               = [[IA-32]], [[X86-64|x86-64]], [[Power ISA|Power]], [[SPARC]], [[ARM architecture|ARM 32-64]], [[Engineering:RISC-V|RISC-V]]
 | operating system       = Cross-platform: [[Software:Unix|Unix]], [[Software:MacOS|macOS]], [[Software:Microsoft Windows|Windows]]
 | license                = [[Software:GNU Lesser General Public License|LGPLv2.1]]
 | file ext               = .ml, .mli
 | wikibooks              = Objective Caml
}}
'''OCaml''' ({{IPAc-en|oʊ|ˈ|k|æ|m|əl}} {{respell|oh|KAM|əl}}, formerly '''Objective Caml''') is a [[General-purpose programming language|general-purpose]], [[High-level programming language|high-level]], multi-paradigm programming language which extends the [[Caml]] dialect of [[ML (programming language)|ML]] with [[Object-oriented programming|object-oriented]] features. OCaml was created in 1996 by [[Biography:Xavier Leroy|Xavier Leroy]], Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, and others.

The OCaml toolchain includes an interactive top-level [[Interpreter (computing)|interpreter]], a [[Software:Bytecode|bytecode]] [[Compiler|compiler]], an optimizing native code compiler, a reversible [[Debugger|debugger]], and a package manager (OPAM).  OCaml was initially developed in the context of [[Automated theorem proving|automated theorem proving]], and is used in [[Static program analysis|static analysis]] and [[Formal methods|formal methods]] software. Beyond these areas, it has found use in [[Systems programming|systems programming]], [[Web development|web development]], and specific financial utilities, among other application domains.

The acronym ''CAML'' originally stood for ''Categorical Abstract Machine Language'', but OCaml omits this [[Abstract machine|abstract machine]].<ref>{{cite web|url= http://ocaml.org/learn/history.html|title= A History of OCaml|access-date= 24 December 2016}}</ref> OCaml is a [[Free and open-source software|free and open-source software]] project managed and principally maintained by the French Institute for Research in Computer Science and Automation (Inria). In the early 2000s, elements from OCaml were adopted by many languages, notably [[F Sharp (programming language)|F#]] and [[Scala (programming language)|Scala]].

==Philosophy==
[[ML (programming language)|ML]]-derived languages are best known for their static [[Type system|type system]]s and [[Type inference|type-inferring]] compilers. OCaml unifies [[Functional programming|functional]], [[Imperative programming|imperative]], and [[Object-oriented programming|object-oriented programming]] under an ML-like type system. Thus, programmers need not be highly familiar with the pure functional language paradigm to use OCaml.

By requiring the programmer to work within the constraints of its static type system, OCaml eliminates many of the type-related [[Run-time type information|runtime]] problems associated with [[Type system|dynamically typed]] languages. Also, OCaml's type-inferring compiler greatly reduces the need for the manual type annotations that are required in most statically typed languages. For example, the [[Data type|data type]]s of variables and the [[Type signature|signature]]s of functions usually need not be declared explicitly, as they do in languages like [[Java (programming language)|Java]] and [[C Sharp (programming language)|C#]], because they can be inferred from the operators and other functions that are applied to the variables and other values in the code. Effective use of OCaml's type system can require some sophistication on the part of a programmer, but this discipline is rewarded with reliable, high-performance software. 

OCaml is perhaps most distinguished from other languages with origins in academia by its emphasis on performance. Its static type system prevents runtime type mismatches and thus obviates runtime type and safety checks that burden the performance of dynamically typed languages, while still guaranteeing runtime safety, except when array bounds checking is turned off or when some type-unsafe features like [[Serialization|serialization]] are used. These are rare enough that avoiding them is quite possible in practice.

Aside from type-checking overhead, [[Functional programming|functional programming]] languages are, in general, challenging to compile to efficient machine language code, due to issues such as the [[Funarg problem|funarg problem]]. Along with standard loop, register, and instruction optimizations, OCaml's [[Optimizing compiler|optimizing compiler]] employs [[Static program analysis|static program analysis]] methods to optimize value [[Boxing (computer science)|boxing]] and closure allocation, helping to maximize the performance of the resulting code even if it makes extensive use of functional programming constructs.

[[Biography:Xavier Leroy|Xavier Leroy]] has stated that "OCaml delivers at least 50% of the performance of a decent C compiler",<ref name = "LWN">[https://lwn.net/Articles/19378/ Linux Weekly News].</ref> although a direct comparison is impossible. Some functions in the OCaml standard library are implemented with faster algorithms than equivalent functions in the standard libraries of other languages. For example, the implementation of set union in the OCaml standard library in theory is asymptotically faster than the equivalent function in the standard libraries of imperative languages (e.g., C++, Java) because the OCaml implementation can exploit the immutability of sets to reuse parts of input sets in the output (see [[Persistent data structure|persistent data structure]]).

== History ==

=== Development of ML (Meta Language) ===
Between the 1970s and 1980s, [[Biography:Robin Milner|Robin Milner]], a British computer scientist and Turing Award winner, worked at the [[Organization:University of Edinburgh|University of Edinburgh]]'s Laboratory for Foundations of Computer Science.<ref>{{Cite web |title=A J Milner - A.M. Turing Award Laureate |url=https://amturing.acm.org/award_winners/milner_1569367.cfm |access-date=2022-10-06 |website=amturing.acm.org}}</ref><ref name=":0">{{Cite web |last=al. |first=Michael Clarkson et |title=1.2. OCaml · Functional Programming in OCaml |url=https://courses.cs.cornell.edu/cs3110/2021sp/textbook/intro/ocaml.html |access-date=2022-10-06 |website=courses.cs.cornell.edu}}</ref> Milner and others were working on [[Automated theorem proving|theorem provers]], which were historically developed in languages such as [[Lisp (programming language)|Lisp]]. Milner repeatedly ran into the issue that the theorem provers would attempt to claim a [[Proof (truth)|proof]] was valid by putting non-proofs together.<ref name=":0" /> As a result, he went on to develop the [[ML (programming language)|meta language]] for his [[Logic for Computable Functions]], a language that would only allow the writer to construct valid proofs with its polymorphic type system.<ref name=":1">{{Cite web |title=Prologue - Real World OCaml |url=https://dev.realworldocaml.org/prologue.html#a-brief-history |access-date=2022-10-06 |website=dev.realworldocaml.org}}</ref> ML was turned into a [[Compiler|compiler]] in order to simplify using LCF on different machines, and, by the 1980s, was turned into a complete system of its own.<ref name=":1" /> ML would eventually serve as a basis for the creation of OCaml.

In the early 1980s, there were some developments that prompted INRIA's Formel team to become interested in the ML language. [[Biography:Luca Cardelli|Luca Cardelli]], a research professor at [[Organization:University of Oxford|University of Oxford]], used his Functional Abstract Machine to develop a faster implementation of ML, and Robin Milner proposed a new definition of ML in order to avoid divergence between various implementations. Simultaneously, Pierre-Louis Curien, a senior researcher at [[Organization:Paris Diderot University|Paris Diderot University]], developed a calculus of categorical combinators and linked it to [[Lambda calculus|lambda calculus]], which led to the definition of the [[Categorical abstract machine|Categorical Abstract Machine]] (CAM). Guy Cousineau, a researcher at Paris Diderot University, recognized that this could be applied as a compilation technique for ML.<ref name=":2">{{Cite web |title=A History of OCaml – OCaml |url=https://v2.ocaml.org/learn/history.html |access-date=2022-10-07 |website=v2.ocaml.org}}</ref>

=== First implementation ===
[[Caml]] was initially designed and developed by INRIA's Formel team headed by [[Biography:Gérard Huet|Gérard Huet]]. The first implementation of Caml was created in 1987 and was further developed until 1992. Though it was spearheaded by Ascánder Suárez, Pierre Weis and Michel Mauny carried on with development after he left in 1988.<ref name=":2" />

Guy Cousineau is quoted recalling that his experience with programming language implementation was initially very limited, and that there were multiple inadequacies for which he is responsible. Despite this, he believes that "Ascander, Pierre and Michel did quite a nice piece of work.”<ref name=":2" />

=== Caml Light ===
Between 1990 and 1991, [[Biography:Xavier Leroy|Xavier Leroy]] designed a new implementation of Caml based on a bytecode interpreter written in [[C (programming language)|C]]. In addition to this, Damien Doligez wrote a memory management system, also known as a sequential [[Garbage collection (computer science)|garbage collector]], for this implementation.<ref name=":1" /> This new implementation, known as Caml Light, replaced the old Caml implementation and ran on small desktop machines.<ref name=":2" /> In the following years, libraries such as Michel Mauny's syntax manipulation tools appeared and helped promote the use of Caml in educational and research teams.<ref name=":1" />

=== Caml Special Light ===
In 1995, Xavier Leroy released Caml Special Light, which was an improved version of Caml.<ref name=":2" /> An optimizing native-code compiler was added to the bytecode compiler, which greatly increased performance to comparable levels with mainstream languages such as [[C++]].<ref name=":1" /><ref name=":2" /> Additionally, Leroy designed a high-level module system inspired by the module system of Standard ML which provided powerful facilities for abstraction and parameterization and made larger-scale programs easier to construct.<ref name=":1" />

=== Objective Caml ===
Didier Rémy and Jérôme Vouillon designed an expressive [[Type system|type system]] for objects and classes, which was integrated within Caml Special Light. This led to the emergence of the Objective Caml language, first released in 1996 and subsequently renamed to OCaml in 2011. This object system notably supported many prevalent object-oriented idioms in a statically type-safe way, while those same idioms caused unsoundness or required runtime checks in languages such as C++ or [[Java (programming language)|Java]]. In 2000, Jacques Garrigue extended Objective Caml with multiple new features such as polymorphic methods, variants, and labeled and optional arguments.<ref name=":1" /><ref name=":2" />

=== Ongoing development ===
Language improvements have been incrementally added for the last two decades in order to support the growing commercial and academic codebases in OCaml.<ref name=":1" /> The OCaml 4.0 release in 2012 added Generalized Algebraic Data Types (GADTs) and first-class modules in order to increase the flexibility of the language.<ref name=":1" /> The OCaml 5.0.0 release in 2022<ref>{{Cite web |title=Release of OCaml 5.0.0 OCaml Package |url=https://ocaml.org/news/ocaml-5.0 |access-date=2022-12-16 |website=OCaml |language=en}}</ref> is a complete rewrite of the language runtime, removing the [[Global interpreter lock|global GC lock]] and adding [[Effect system|effect handlers]] via delimited continuations. These changes enable support for [[Parallel programming model#Shared memory|shared-memory parallelism]] and color-blind concurrency respectively.

OCaml's development continued within the Cristal team at INRIA until 2005, when it was succeeded by the Gallium team.<ref>{{Cite web |title=Projet Cristal |url=http://cristal.inria.fr/ |access-date=2022-10-07 |website=cristal.inria.fr}}</ref> Subsequently, Gallium was succeeded by the Cambium team in 2019.<ref>{{Cite web |title=Gallium team - Home |url=http://gallium.inria.fr/ |access-date=2022-10-07 |website=gallium.inria.fr}}</ref><ref>{{Cite web |title=Home |url=http://cambium.inria.fr/ |access-date=2022-10-07 |website=cambium.inria.fr |language=en}}</ref> As of 2023, there are 23 core developers of the compiler distribution from a variety of organizations<ref>{{cite web|url=https://ocaml.org/governance/compiler|title=OCaml compiler governance and membership|year=2023}}</ref> and 41 developers for the broader OCaml tooling and packaging ecosystem.<ref>{{cite web|url=https://ocaml.org/governance|title=OCaml governance and projects|year=2023}}</ref>

==Features==
OCaml features a static [[Type system|type system]], [[Type inference|type inference]], [[Parametric polymorphism|parametric polymorphism]], [[Tail recursion|tail recursion]], [[Pattern matching|pattern matching]], first class lexical closures, [[Function object#Other meanings|functors (parametric modules)]], [[Exception handling|exception handling]], [[Effect system|effect handling]], and incremental generational [[Garbage collection (computer science)|automatic garbage collection]].

OCaml is notable for extending ML-style type inference to an object system in a general-purpose language. This permits structural subtyping, where object types are compatible if their method signatures are compatible, regardless of their declared inheritance (an unusual feature in statically typed languages).

A [[Foreign function interface|foreign function interface]] for [[Linker (computing)|linking]] to [[C (programming language)|C]] primitives is provided, including language support for efficient numerical [[Array data structure|arrays]] in formats compatible with both C and [[Fortran]]. OCaml also supports creating libraries of OCaml functions that can be linked to a ''main'' program in C, so that an OCaml library can be distributed to C programmers who have no knowledge or installation of OCaml.

The OCaml distribution contains:
* [[Lexical analysis]] and [[Parsing|parsing]] tools called ''ocamllex'' and ''ocamlyacc''
* [[Debugger]] that supports stepping backwards to investigate errors
* [[Software:Documentation generator|Documentation generator]]
* Profiler – to measure performance
* Many general-purpose [[Library (computing)|libraries]]

The native code compiler is available for many platforms, including [[Software:Unix|Unix]], [[Software:Microsoft Windows|Microsoft Windows]], and [[Company:Apple Inc.|Apple]] [[Software:MacOS|macOS]]. Portability is achieved through native [[Code generation (compiler)|code generation]] support for major architectures: 

* [[X86-64]] (AMD64), [[Engineering:RISC-V|RISC-V]], and ARM64 (in OCaml 5.0.0 and higher)<ref>{{cite web|url=https://github.com/ocaml/ocaml/tree/trunk/asmcomp|title=ocaml/asmcomp at trunk · ocaml/ocaml · GitHub|work=GitHub|access-date=2 May 2015}}</ref>
* [[IBM Z]] (before OCaml 5.0.0, and back in OCaml 5.1.0)
* [[Power ISA|Power]] (before OCaml 5.0.0, and due to reappear in OCaml 5.2.0)
* [[IA-32]] and [[ARM architecture|ARM]] (before OCaml 5.0.0)
* [[SPARC]] (before OCaml 4.06.0)
* [[DEC Alpha]], HPPA, IA64 and [[MIPS architecture|MIPS]] (before OCaml 4.00.0)

The bytecode compiler supports operation on any 32- or 64-bit architecture when native code generation is not available, requiring only a C compiler.

OCaml bytecode and native code programs can be written in a multithreaded style, with preemptive context switching. OCaml threads in the same domain<ref>A domain is a unit of parallelism in OCaml, a domain usually corresponds to a CPU core</ref> execute by time sharing only. However, an OCaml program can contain several domains. There are several libraries for distributed computing such as [http://functory.lri.fr/About.html Functory] and [http://projects.camlcity.org/projects/ocamlnet.html ocamlnet/Plasma].

==Development environment==

Since 2011, many new tools and libraries have been contributed to the OCaml development environment:<ref>{{cite web|url=https://ocaml.org/docs/platform|title=The OCaml Platform|year=2023|author=The OCaml.org maintainers}}</ref>
* Development tools
** [https://opam.ocaml.org/ opam] is a package manager for OCaml.
** [https://github.com/ocaml/merlin Merlin] provides IDE-like functionality for multiple editors, including type throwback, go-to-definition, and auto-completion.
** [https://github.com/ocaml/dune Dune] is a composable build-system for OCaml.
** [https://github.com/ocaml-ppx/ocamlformat OCamlformat] is an auto-formatter for OCaml.
**[https://github.com/ocaml/ocaml-lsp ocaml-lsp-server] is a [[Language Server Protocol]] for OCaml [[Integrated development environment|IDE]] integration.
* Web sites:
** [https://ocaml.org/ OCaml.org] is the primary site for the language.
** [https://discuss.ocaml.org/ discuss.ocaml.org] is an instance of [[Software:Discourse|Discourse]] that serves as the primary discussion site for OCaml.
** [https://watch.ocaml.org/ watch.ocaml.org] is an instance of [[Software:PeerTube|PeerTube]] that hosts videos about OCaml topics.
* Alternate compilers for OCaml:
** [https://github.com/ocsigen/js_of_ocaml js_of_ocaml], developed by the Ocsigen team, is an optimizing compiler from OCaml to [[JavaScript]].
** [https://bucklescript.github.io/ BuckleScript], which also targets [[JavaScript]], with a focus on producing readable, idiomatic JavaScript output.
** ocamlcc is a compiler from OCaml to C, to complement the native code compiler for unsupported platforms.
** OCamlJava, developed by INRIA, is a compiler from OCaml to the [[Java virtual machine]] (JVM).
** OCaPic, developed by Lip6, is an OCaml compiler for PIC microcontrollers.

==Code examples==
Snippets of OCaml code are most easily studied by entering them into the ''top-level [[Read–eval–print loop|REPL]]''. This is an interactive OCaml session that prints the inferred types of resulting or defined expressions.<ref>{{Cite web|title=OCaml - The toplevel system or REPL (ocaml)|url=https://ocaml.org/manual/toplevel.html|access-date=2021-05-17|website=ocaml.org}}</ref> The OCaml top-level is started by simply executing the OCaml program:

<source lang="console">
$ ocaml
     Objective Caml version 3.09.0
#
</source>
Code can then be entered at the "#" prompt. For example, to calculate 1+2*3:
<source lang="console">
# 1 + 2 * 3;;
- : int = 7
</source>

OCaml infers the type of the expression to be "int" (a [[Word (computer architecture)|machine-precision]] [[Integer (computer science)|integer]]) and gives the result "7".

===Hello World===
The following program "hello.ml":

<source lang="OCaml">
print_endline "Hello World!"
</source>

can be compiled into a bytecode executable:

 $ ocamlc hello.ml -o hello

or compiled into an optimized native-code executable:

 $ ocamlopt hello.ml -o hello

and executed:

<source lang="console">
$ ./hello
Hello World!
$
</source>

The first argument to ocamlc, "hello.ml", specifies the source file to compile and the "-o hello" flag specifies the output file.<ref>{{Cite web|url=https://caml.inria.fr/pub/docs/manual-ocaml/comp.html|title = OCaml - Batch compilation (Ocamlc)}}</ref>

=== Option ===
The <code>option</code> type constructor in OCaml, similar to the <code>Maybe</code> type in [[Haskell]], augments a given data type to either return <code>Some</code> value of the given data type, or to return <code>None</code>.<ref>{{Cite web |title=3.7. Options — OCaml Programming: Correct + Efficient + Beautiful |url=https://cs3110.github.io/textbook/chapters/data/options.html |access-date=2022-10-07 |website=cs3110.github.io}}</ref> This is used to express that a value might or might not be present.<source lang="ocaml">
# Some 42;;
- : int option = Some 42
# None;;
- : 'a option = None
</source>This is an example of a function that either extracts an int from an option, if there is one inside, and converts it into a string, or if not, returns an empty string:<source lang="ocaml">
let extract o =
  match o with
  | Some i -> string_of_int i
  | None -> "";;
</source><source lang="ocaml">
# extract (Some 42);;
- : string = "42"
# extract None;;
- : string = ""
</source>

===Summing a list of integers===

Lists are one of the fundamental datatypes in OCaml. The following code example defines a [[Recursion (computer science)|recursive]] function ''sum'' that accepts one argument, ''integers'', which is supposed to be a list of integers. Note the keyword <code>rec</code> which denotes that the function is recursive. The function recursively iterates over the given list of integers and provides a sum of the elements. The ''match'' statement has similarities to [[C (programming language)|C]]'s [[Switch statement|switch]] element, though it is far more general.

<source lang="ocaml">
let rec sum integers =                   (* Keyword rec means 'recursive'. *)
  match integers with
  | [] -> 0                              (* Yield 0 if integers is the empty 
                                            list []. *)
  | first :: rest -> first + sum rest;;  (* Recursive call if integers is a non-
                                            empty list; first is the first 
                                            element of the list, and rest is a 
                                            list of the rest of the elements, 
                                            possibly []. *)
</source>
<source lang="OCaml">
  # sum [1;2;3;4;5];;
  - : int = 15
</source>

Another way is to use standard fold function that works with lists.

<source lang="ocaml">
let sum integers =
  List.fold_left (fun accumulator x -> accumulator + x) 0 integers;;
</source>
<source lang="OCaml">
  # sum [1;2;3;4;5];;
  - : int = 15
</source>

Since the [[Anonymous function|anonymous function]] is simply the application of the + operator, this can be shortened to:

<source lang="ocaml">
let sum integers =
  List.fold_left (+) 0 integers
</source>

Furthermore, one can omit the list argument by making use of a [[Partial application|partial application]]:

<source lang="OCaml">
let sum =
  List.fold_left (+) 0
</source>

===Quicksort===
OCaml lends itself to concisely expressing recursive algorithms. The following code example implements an algorithm similar to [[Quicksort|quicksort]] that sorts a list in increasing order.

<source lang="OCaml">
 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
</source>

Or using partial application of the >= operator.

<source lang="OCaml">
 let rec qsort = function
   | [] -> []
   | pivot :: rest ->
     let is_less = (>=) pivot in
     let left, right = List.partition is_less rest in
     qsort left @ [pivot] @ qsort right
</source>

===Birthday problem===
The following program calculates the smallest number of people in a room for whom the probability of completely unique birthdays is less than 50% (the [[Birthday problem|birthday problem]], where for 1 person the probability is 365/365 (or 100%), for 2 it is 364/365, for 3 it is 364/365 × 363/365, etc.) (answer = 23).

<source lang="OCaml">
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
</source>

===Church numerals===
The following code defines a [[Church encoding]] of [[Natural number|natural number]]s, with successor (succ) and addition (add). A Church numeral {{OCaml|n}} is a [[Higher-order function|higher-order function]] that accepts a function {{OCaml|f}} and a value {{OCaml|x}} and applies {{OCaml|f}} to {{OCaml|x}} exactly {{OCaml|n}} times. To convert a Church numeral from a functional value to a string, we pass it a function that prepends the string {{OCaml|"S"}} to its input and the constant string {{OCaml|"0"}}.

<source lang="OCaml">
let zero f x = x
let succ n f x = f (n f x)
let one = succ zero
let two = succ (succ zero)
let add n1 n2 f x = n1 f (n2 f x)
let to_string n = n (fun k -> "S" ^ k) "0"
let _ = to_string (add (succ two) two)
</source>

===Arbitrary-precision factorial function (libraries)===
A variety of libraries are directly accessible from OCaml. For example, OCaml has a built-in library for [[Arbitrary-precision arithmetic|arbitrary-precision arithmetic]]. As the factorial function grows very rapidly, it quickly overflows machine-precision numbers (typically 32- or 64-bits). Thus, factorial is a suitable candidate for arbitrary-precision arithmetic.

In OCaml, the Num module (now superseded by the ZArith module) provides arbitrary-precision arithmetic and can be loaded into a running top-level using:
<source lang=ocaml>
# #use "topfind";;
# #require "num";;
# open Num;;
</source>

The factorial function may then be written using the arbitrary-precision numeric operators {{mono|{{=}}/}}, {{mono|*/}} and {{mono|-/}} :

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

This function can compute much larger factorials, such as 120!:

<source lang="OCaml">
# string_of_num (fact (Int 120));;
- : string =
"6689502913449127057588118054090372586752746333138029810295671352301633
55724496298936687416527198498130815763789321409055253440858940812185989
8481114389650005964960521256960000000000000000000000000000"
</source>

===Triangle (graphics)===
The following program renders a rotating triangle in 2D using [[Software:OpenGL|OpenGL]]:

<source lang="OCaml">
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 ()
</source>

The LablGL bindings to OpenGL are required. The program may then be compiled to bytecode with:

 $ ocamlc -I +lablGL lablglut.cma lablgl.cma simple.ml -o simple

or to nativecode with:

 $ ocamlopt -I +lablGL lablglut.cmxa lablgl.cmxa simple.ml -o simple

or, more simply, using the ocamlfind build command
 $ ocamlfind opt simple.ml -package lablgl.glut -linkpkg -o simple

and run:

 $ ./simple

Far more sophisticated, high-performance 2D and 3D graphical programs can be developed in OCaml. Thanks to the use of OpenGL and OCaml, the resulting programs can be cross-platform, compiling without any changes on many major platforms.

===Fibonacci sequence===
The following code calculates the [[Fibonacci number|Fibonacci sequence]] of a number ''n'' inputted. It uses [[Tail recursion|tail recursion]] and pattern matching.
<source lang = OCaml>
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
</source>

===Higher-order functions===
Functions may take functions as input and return functions as result. For example, applying ''twice'' to a function ''f'' yields a function that applies ''f'' two times to its argument.
<source lang = OCaml>
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);;
</source>
<source lang = OCaml highlight="1,3">
  # add2 98;;
  - : int = 100
  # add_str "Test";;
  - : string = "Test Test Test Test"
</source>
The function ''twice'' uses a type variable'' 'a'' to indicate that it can be applied to any function ''f'' mapping from a type'' 'a'' to itself, rather than only to ''int->int'' functions. In particular, ''twice'' can even be applied to itself.
<source lang = OCaml highlight="1,3,5">
  # 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
</source>

==Derived languages==

===MetaOCaml===
MetaOCaml<ref name = "Meta">{{cite web|url=http://okmij.org/ftp/ML/MetaOCaml.html|title=BER MetaOCaml|last=oleg-at-okmij.org|website=okmij.org}}</ref> is a [[Multi-stage programming|multi-stage programming]] extension of OCaml enabling incremental compiling of new [[Machine code|machine code]] during runtime. Under some circumstances, significant speedups are possible using multistage programming, because more detailed information about the data to process is available at runtime than at the regular compile time, so the incremental compiler can optimize away many cases of condition checking, etc.

As an example: if at compile time it is known that some [[Exponentiation|power function]] {{OCaml|x -> x^n}} is needed often, but the value of {{OCaml|n}} is known only at runtime, a two-stage power function can be used in MetaOCaml:

<source lang="OCaml">
let rec power n x =
  if n = 0
  then .<1>.
  else
    if even n
    then sqr (power (n/2) x)
    else .<.~x *. .~(power (n - 1) x)>.
</source>

As soon as {{OCaml|n}} is known at runtime, a specialized and very fast power function can be created:

<source lang="OCaml">
.<fun x -> .~(power 5 .<x>.)>.
</source>

The result is:

<source lang="OCaml">
fun x_1 -> (x_1 *
    let y_3 = 
        let y_2 = (x_1 * 1)
        in (y_2 * y_2)
    in (y_3 * y_3))
</source>

The new function is automatically compiled.

===Other derived languages===
* AtomCaml provides a synchronization primitive for atomic (transactional) execution of code.
* [http://wiki.erights.org/wiki/Emily Emily] (2006) is a subset of OCaml 3.08 that uses a design rule verifier to enforce [[Object-capability model|object-capability model]] [[Capability-based security|security]] principles.
* [[F Sharp (programming language)|F#]] is a .NET Framework language based on OCaml.
* Fresh OCaml facilitates manipulating names and binders.
* GCaml adds extensional polymorphism to OCaml, thus allowing overloading and type-safe marshalling.
* [[Software:JoCaml|JoCaml]] integrates constructions for developing concurrent and distributed programs.
* OCamlDuce extends OCaml with features such as XML expressions and regular-expression types.
* OCamlP3l is a parallel programming system based on OCaml and the P3L language.
* [[Reason (programming language)|Reason]] is an alternative OCaml [[Syntax (programming languages)|syntax]] and toolchain for OCaml created at [[Company:Facebook|Facebook]], which can compile to both native code and JavaScript.
* ReScript is a rebranding and new language from the Reason/BuckleScript toolchain, which has different syntax and only compiles to JavaScript.

==Software written in OCaml==
* [[Software:Zero Install|0install]], a multi-platform package manager.
* CamlPDF, an OCaml library for reading, writing and modifying PDF files<ref>{{cite web|url=https://github.com/johnwhitington/camlpdf|title=GitHub - johnwhitington/camlpdf|website=[[GitHub]] |date=14 December 2022 }}</ref>
* Coccinelle, a utility for [[Program transformation|transforming]] the [[Source code|source code]] of [[C (programming language)|C]] programs.
* [[Software:Coq|Coq]], a [[Formal proof|formal proof]] management system.
* [[Software:FFTW|FFTW]], a [[Library (computing)|library]] for computing [[Discrete Fourier transform|discrete Fourier transform]]s. Several C routines have been generated by an OCaml program named {{OCaml|genfft}}.
* The web version of [[Software:Facebook Messenger|Facebook Messenger]].<ref>{{cite web|title=Messenger.com Now 50% Converted to Reason · Reason|url=https://reasonml.github.io/blog/2017/09/08/messenger-50-reason.html|website=reasonml.github.io|access-date=2018-02-27}}</ref>
* Flow, a [[Static program analysis|static analyzer]] created at [[Company:Facebook|Facebook]] that infers and checks [[Type system#Static type checking|static types]] for [[JavaScript]].<ref>{{cite web|url=https://flow.org/en/|title=Flow: A Static Type Checker for JavaScript|website=Flow}}</ref>
* [[Software:Owl Scientific Computing|Owl Scientific Computing]], a dedicated system for scientific and engineering computing.
* [[Software:Frama-C|Frama-C]], a framework for analyzing C programs.
* [[Software:GeneWeb|GeneWeb]], free and open-source multi-platform genealogy software.
* The [[Hack (programming language)|Hack]] programming language compiler, created at Facebook, extending [[Organization:PHP|PHP]] with static types.
* The [[Haxe]] programming language compiler.
* [[Software:HOL Light|HOL Light]], a formal proof assistant.
* Infer, a static analyzer created at Facebook for [[Java (programming language)|Java]], C, [[C++]], and [[Objective-C]], used to detect bugs in [[Software:IOS|iOS]] and [[Software:Android (operating system)|Android]] apps.<ref>{{cite web|url=https://fbinfer.com/|title=Infer static analyzer|website=Infer}}</ref>
* [https://www.lexifi.com/apropos/ Lexifi Apropos], a system for modeling complex derivatives.
* [[Software:Liquidsoap|Liquidsoap]], a [[Scripting language|scripting language]] for generating multimedia streams.
* Mina Protocol, a [[Finance:Cryptocurrency|cryptocurrency]] and [[Finance:Smart contract|smart contract]] system using zk-SNARKs to compress its blockchain.
* MirageOS, a [[Software:Unikernel|unikernel]] programming framework written in pure OCaml.
* MLdonkey, a [[Peer-to-peer file sharing|peer-to-peer file sharing]] application based on the [[EDonkey network]].
* Ocsigen, an OCaml [[Software:Web framework|web framework]].
* [[Opa (programming language)|Opa]], a free and open-source programming language for web development.
* pyre-check, a type checker for [[Python (programming language)|Python]] created at Facebook.<ref>{{cite web|url=https://github.com/facebook/pyre-check|title=GitHub - facebook/pyre-check: Performant type-checking for python.|date=9 February 2019|via=GitHub}}</ref>
* [https://semgrep.dev/ Semgrep], a bug-finding tool supporting many programming languages.
* [[Finance:Tezos|Tezos]], a self-amending smart contract platform using XTZ as a native currency.
* Unison, a [[File synchronization|file synchronization]] program to synchronize files between two directories.
* The reference interpreter for [[WebAssembly]], a low-level [[Software:Bytecode|bytecode]] intended for execution inside [[Software:Web browser|web browser]]s.<ref>{{cite web|url=https://github.com/WebAssembly/spec|title=WebAssembly/spec: WebAssembly specification, reference interpreter, and test suite.|date=5 December 2019|publisher=[[Organization:World Wide Web Consortium|World Wide Web Consortium]]|access-date=2021-05-14|via=GitHub}}</ref>
* Xen Cloud Platform (XCP), a [[Turnkey|turnkey]] [[Virtualization|virtualization]] solution for the [[Software:Xen|Xen]] [[Hypervisor|hypervisor]].

==Users==
At least several dozen companies use OCaml to some degree.<ref name="ocaml.org-companies">{{Cite web|url=https://ocaml.org/learn/companies.html|title=Companies using OCaml|access-date=2021-05-14|publisher=OCaml.org}}</ref> Notable examples include:
* [[Company:Bloomberg L.P.|Bloomberg L.P.]], which created [https://bucklescript.github.io/ BuckleScript], an OCaml compiler backend targeting JavaScript.<ref>{{cite web|url=https://www.techatbloomberg.com/blog/bucklescript-1-0-release-arrived/|title=BuckleScript: The 1.0 release has arrived! {{!}} Tech at Bloomberg|date=8 September 2016|website=Tech at Bloomberg|ref=12|access-date=21 May 2017}}</ref>
* [[Company:Citrix Systems|Citrix Systems]], which uses OCaml in [[Company:Citrix Systems#Networking and cloud|XenServer]] (rebranded as Citrix Hypervisor during 2018).<ref>{{cite conference|url=https://dl.acm.org/doi/10.1145/1863543.1863557|doi=10.1145/1863543.1863557|first1=David|last1=Scott|first2=Richard|last2=Sharp|first3=Thomas|last3=Gazagnaire|first4=Anil|last4=Madhavapeddy|title=Using functional programming within an industrial product group: perspectives and perceptions|publisher=[[Organization:Association for Computing Machinery|Association for Computing Machinery]]|conference=[[International Conference on Functional Programming]]|year=2010}}</ref>
* [[Company:Facebook|Facebook]], which developed Flow,<ref>{{cite web|url=https://github.com/facebook/flow|title=Flow on GitHub|website=[[GitHub]] |year=2023}}</ref> Hack, Infer, Pfff, and [[Reason (programming language)|ReasonML]] in OCaml.
* Jane Street Capital, a [[Finance:Proprietary trading|proprietary trading]] firm, which adopted OCaml as its preferred language in its early days<ref>{{cite web|url=http://cacm.acm.org/magazines/2011/11/138203-ocaml-for-the-masses/fulltext|title=OCaml for the Masses|author=Yaron Minsky|date=1 November 2011|access-date=2 May 2015}}</ref> and continues to use it as of 2023.<ref>{{cite web|url=http://cufp.org/2016/yaron-minsky-keynote.html|title= Keynote - Observations of a Functional Programmer|author=Yaron Minsky|publisher=[[Organization:Association for Computing Machinery|ACM]] Commercial Uses of Functional Programming|year=2016}}</ref><ref>{{cite podcast|title=Signals & Threads|year=2023|publisher=Jane Street Capital|url=https://signalsandthreads.com|host=Yaron Minsky}}</ref>
* [[Software:Docker|Docker]], which uses OCaml in the desktop editions on [[Software:MacOS|macOS]] and [[Software:Windows|Windows]].<ref>{{cite web|url=https://www.docker.com/blog/docker-unikernels-open-source/|title=Improving Docker with Unikernels: Introducing HyperKit, VPNKit and DataKit|author=Anil Madhavapeddy|year=2016|publisher=[[Company:Docker, Inc.|Docker, Inc.]]}}</ref><ref>{{cite web|url=https://github.com/moby/vpnkit|title=VPNKit on GitHub|website=[[GitHub]] |year=2023}}</ref>
==References==
{{Reflist}}

==External links==
* [https://v2.ocaml.org/manual/ OCaml manual]
* [https://opam.ocaml.org/ OCaml Package Manager]
* [https://dev.realworldocaml.org/ Real World OCaml]

{{Programming languages}}


[[Category:Cross-platform free software]]
[[Category:Extensible syntax programming languages]]
[[Category:Free compilers and interpreters]]
[[Category:Functional languages]]
[[Category:ML programming language family]]
[[Category:Object-oriented programming languages]]
[[Category:Pattern matching programming languages]]
[[Category:Statically typed programming languages]]

{{Sourceattribution|OCaml}}