OCaml

Programming language

Not to be confused with occam (programming language).

OCaml

Paradigms| Multi-paradigm: functional, imperative, modular,[1] 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; 28 years ago (1996)[2]
Stable release|

5.2.0[3] / 13 May 2024; 3 months ago (13 May 2024)

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
Website| ocaml.org
Influenced by
C, Caml, Modula-3, Pascal, Standard ML
Influenced
ATS, Coq, Elm, F#, F*, Haxe, Opa, Rust,[4] Scala

* Objective Caml at Wikibooks

OCaml (/oʊˈkæməl/ oh-KAM-əl, formerly Objective Caml) is a general-purpose, high-level, multi-paradigm programming language which extends the Caml dialect of ML with object-oriented features. OCaml was created in 1996 by Xavier Leroy, Jérôme Vouillon,[5] Damien Doligez, Didier Rémy,[6] Ascánder Suárez, and others.

The OCaml toolchain includes an interactive top-level interpreter, a bytecode compiler, an optimizing native code compiler, a reversible debugger, and a package manager (OPAM). OCaml was initially developed in the context of automated theorem proving, and is used in static analysis and formal methods software. Beyond these areas, it has found use in systems programming, 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.[7] OCaml is a 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# and Scala.

## Philosophy

[edit]

ML-derived languages are best known for their static type systems and type-inferring compilers. OCaml unifies functional, imperative, and 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 runtime problems associated with 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 types of variables and the signatures of functions usually need not be declared explicitly, as they do in languages like Java and 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 are used. These are rare enough that avoiding them is quite possible in practice.

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

Xavier Leroy has stated that "OCaml delivers at least 50% of the performance of a decent C compiler",[8] 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).

## History

[edit]

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

### Development of ML (Meta Language)

[edit]

Between the 1970s and 1980s, Robin Milner, a British computer scientist and Turing Award winner, worked at the University of Edinburgh's Laboratory for Foundations of Computer Science.[9][10] Milner and others were working on theorem provers, which were historically developed in languages such as Lisp. Milner repeatedly ran into the issue that the theorem provers would attempt to claim a proof was valid by putting non-proofs together.[10] As a result, he went on to develop the 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.[11] ML was turned into a compiler to simplify using LCF on different machines, and, by the 1980s, was turned into a complete system of its own.[11] 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. Luca Cardelli, a research professor at University of Oxford, used his functional abstract machine to develop a faster implementation of ML, and Robin Milner proposed a new definition of ML to avoid divergence between various implementations. Simultaneously, Pierre-Louis Curien, a senior researcher at Paris Diderot University, developed a calculus of categorical combinators and linked it to lambda calculus, which led to the definition of the categorical abstract machine (CAM). Guy Cousineau, a researcher at Paris Diderot University, recognized that this could be applied as a compiling method for ML.[12]

### First implementation

[edit]

Caml was initially designed and developed by INRIA's Formel team headed by 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.[12]

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.”[12]

### Caml Light

[edit]

Between 1990 and 1991, Xavier Leroy designed a new implementation of Caml based on a bytecode interpreter written in C. In addition to this, Damien Doligez wrote a memory management system, also known as a sequential garbage collector, for this implementation.[11] This new implementation, known as Caml Light, replaced the old Caml implementation and ran on small desktop machines.[12] 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.[11]

### Caml Special Light

[edit]

In 1995, Xavier Leroy released Caml Special Light, which was an improved version of Caml.[12] An optimizing native-code compiler was added to the bytecode compiler, which greatly increased performance to comparable levels with mainstream languages such as C++.[11][12] Also, 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 build.[11]

### Objective Caml

[edit]

Didier Rémy and Jérôme Vouillon designed an expressive 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. In 2000, Jacques Garrigue extended Objective Caml with multiple new features such as polymorphic methods, variants, and labeled and optional arguments.[11][12]

### Ongoing development

[edit]

Language improvements have been incrementally added for the last two decades to support the growing commercial and academic codebases in OCaml.[11] The OCaml 4.0 release in 2012 added Generalized Algebraic Data Types (GADTs) and first-class modules to increase the flexibility of the language.[11] The OCaml 5.0.0 release in 2022[13] is a complete rewrite of the language runtime, removing the global GC lock and adding effect handlers via delimited continuations. These changes enable support for 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.[14] Subsequently, Gallium was succeeded by the Cambium team in 2019.[15][16] As of 2023, there are 23 core developers of the compiler distribution from a variety of organizations[17] and 41 developers for the broader OCaml tooling and packaging ecosystem.[18]

## Features

[edit]

OCaml features a static type system, type inference, parametric polymorphism, tail recursion, pattern matching, first class lexical closures, functors (parametric modules), exception handling, effect handling, and incremental generational 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 for linking to C primitives is provided, including language support for efficient numerical 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 tools called ocamllex and ocamlyacc
* Debugger that supports stepping backwards to investigate errors
* Documentation generator
* Profiler – to measure performance
* Many general-purpose libraries

The native code compiler is available for many platforms, including Unix, Microsoft Windows, and Apple macOS. Portability is achieved through native code generation support for major architectures:

* X86-64 (AMD64), RISC-V, and ARM64 (in OCaml 5.0.0 and higher)[19]
* IBM Z (before OCaml 5.0.0, and back in OCaml 5.1.0)
* Power (before OCaml 5.0.0, and due to reappear in OCaml 5.2.0)
* IA-32 and ARM (before OCaml 5.0.0)
* SPARC (before OCaml 4.06.0)
* DEC Alpha, HPPA, IA64 and 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[20] execute by time sharing only. However, an OCaml program can contain several domains.

## Code examples

[edit]

This article relies largely or entirely on a single source. Relevant discussion may be found on the talk page. Please help improve this article by introducing citations to additional sources.
Find sources: "OCaml" – news · newspapers · books · scholar · JSTOR (January 2024)

|

Snippets of OCaml code are most easily studied by entering them into the top-level REPL. This is an interactive OCaml session that prints the inferred types of resulting or defined expressions.[21] The OCaml top-level is started by simply executing the OCaml program:

$ ocaml
Objective Caml version 3.09.0

Code can then be entered at the "#" prompt. For example, to calculate 1+2*3:

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

OCaml infers the type of the expression to be "int" (a machine-precision integer) and gives the result "7".

### Hello World

[edit]

The following program "hello.ml":

print_endline "Hello World!"

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:

$ ./hello
Hello World!

The first argument to ocamlc, "hello.ml", specifies the source file to compile and the "-o hello" flag specifies the output file.[22]

### Option

[edit]

The `option` type constructor in OCaml, similar to the `Maybe` type in Haskell, augments a given data type to either return `Some` value of the given data type, or to return `None`.[23] This is used to express that a value might or might not be present.

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

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:

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

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

### Summing a list of integers

[edit]

Lists are one of the fundamental datatypes in OCaml. The following code example defines a recursive function sum that accepts one argument, integers, which is supposed to be a list of integers. Note the keyword `rec` 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's switch element, though it is far more general.

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 []. *)

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

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

let sum integers =
List.fold_left (fun accumulator x -> accumulator + x) 0 integers;;

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

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

let sum integers =
List.fold_left (+) 0 integers

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

let sum =
List.fold_left (+) 0

### Quicksort

[edit]

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

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

Or using partial application of the >= operator.

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

### Birthday problem

[edit]

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, 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).

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

### Church numerals

[edit]

The following code defines a Church encoding of natural numbers, with successor (succ) and addition (add). A Church numeral `n` is a higher-order function that accepts a function `f` and a value `x` and applies `f` to `x` exactly `n` times. To convert a Church numeral from a functional value to a string, we pass it a function that prepends the string `"S"` to its input and the constant string `"0"`.

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)

### Arbitrary-precision factorial function (libraries)

[edit]

A variety of libraries are directly accessible from OCaml. For example, OCaml has a built-in library for 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:

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

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

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

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

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

### Triangle (graphics)

[edit]

The following program renders a rotating triangle in 2D 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 ()

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

[edit]

The following code calculates the Fibonacci sequence of a number n inputted. It uses tail recursion and pattern matching.

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

### Higher-order functions

[edit]

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.

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"

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.

# 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

## Derived languages

[edit]

### MetaOCaml

[edit]

MetaOCaml[24] is a multi-stage programming extension of OCaml enabling incremental compiling of new 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 power function `x -> x^n` is needed often, but the value of `n` is known only at runtime, a two-stage power function can be used in MetaOCaml:

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)>.

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

.<fun x -> .~(power 5 .<x>.)>.

The result is:

fun x_1 -> (x_1 *
let y_3 =
let y_2 = (x_1 * 1)
in (y_2 * y_2)
in (y_3 * y_3))

The new function is automatically compiled.

### Other derived languages

[edit]

* F# is a .NET framework language based on OCaml.
* JoCaml integrates constructions for developing concurrent and distributed programs.
* Reason is an alternative OCaml syntax and toolchain for OCaml created at Facebook, which can compile to both native code and JavaScript.

## Software written in OCaml

[edit]

* Ahrefs, an SEO software product
* Alt-Ergo, a SMT solver.
* Astrée, a static analyzer
* Be Sport, a social network
* Coccinelle, a utility for transforming the source code of C programs.
* Coq, a formal proof management system.
* Easycrypt, a toolset for writing computer-aided proofs.[25]
* F*, a high-level, multi-paradigm, functional and object-oriented programming language intended for program verification.
* FFTW, a library for computing discrete Fourier transforms. Several C routines have been generated by an OCaml program named `genfft`.
* The web version of Facebook Messenger.[26]
* Flow, a static analyzer created at Facebook that infers and checks static types for JavaScript.[27]
* Ocsigen, a client server Web and mobile development framework
* Owl Scientific Computing, a dedicated system for scientific and engineering computing.
* Frama-C, a framework for analyzing C programs.
* GeneWeb, free and open-source multi-platform genealogy software.
* The Hack programming language compiler, created at Facebook, extending PHP with static types.
* The Haxe programming language compiler.
* HOL Light, a formal proof assistant.
* Infer, a static analyzer created at Facebook for Java, C, C++, and Objective-C, used to detect bugs in iOS and Android apps.[28]
* Liquidsoap, a scripting language for generating multimedia streams.
* MirageOS, a unikernel programming framework written in pure OCaml.
* MLdonkey, a peer-to-peer file sharing application based on the EDonkey network.
* Opa, a free and open-source programming language for web development.
* Reason / ReScript, a general-purpose, high-level, multi-paradigm, functional and object-oriented programming language.
* Rust, a general-purpose programming language emphasizing performance, type safety, and concurrency.
* Tezos, a self-amending smart contract platform using XTZ as a native currency.
* Unison, a file synchronization program to synchronize files between two directories.
* The reference interpreter for WebAssembly, a low-level bytecode intended for execution inside web browsers.[29]
* Xen Cloud Platform (XCP), a turnkey virtualization solution for the Xen hypervisor.

## Users

[edit]

At least several dozen companies use OCaml to some degree.[30] Notable examples include:

* Bloomberg L.P., which created BuckleScript, an OCaml compiler backend targeting JavaScript.[31]
* Citrix Systems, which uses OCaml in XenServer (rebranded as Citrix Hypervisor during 2018).[32]
* Facebook, which developed Flow,[33] Hack, Infer, Pfff, and ReasonML in OCaml.
* Jane Street Capital, a proprietary trading firm, which adopted OCaml as its preferred language in its early days[34] and continues to use it as of 2023.[35][36]
* Docker, which uses OCaml in the desktop editions on macOS and Windows.[37][38]

## References

[edit]

1. ^ "Modules". Retrieved 22 February 2020.
2. ^ Leroy, Xavier (1996). "Objective Caml 1.00". caml-list mailing list.
3. ^ "OCaml 5.2.0 Release Notes". Retrieved 24 May 2024.
4. ^ "Influences - The Rust Reference". The Rust Reference. Retrieved 31 December 2023.
5. ^ "Jérôme Vouillon". www.irif.fr. Retrieved 14 June 2024.
6. ^ "Didier Remy". pauillac.inria.fr. Retrieved 14 June 2024.
7. ^ "A History of OCaml". Retrieved 24 December 2016.
8. ^ Linux Weekly News.
9. ^ "A J Milner - A.M. Turing Award Laureate". amturing.acm.org. Retrieved 6 October 2022.
10. ^ a b Clarkson, Michael; et al. "1.2. OCaml: Functional Programming in OCaml". courses.cs.cornell.edu. Retrieved 6 October 2022.
11. ^ a b c d e f g h i "Prologue - Real World OCaml". dev.realworldocaml.org. Retrieved 6 October 2022.
12. ^ a b c d e f g "A History of OCaml – OCaml". v2.ocaml.org. Retrieved 7 October 2022.
13. ^ "Release of OCaml 5.0.0 OCaml Package". OCaml. Retrieved 16 December 2022.
14. ^ "Projet Cristal". cristal.inria.fr. Retrieved 7 October 2022.
15. ^ "Gallium team - Home". gallium.inria.fr. Retrieved 7 October 2022.
16. ^ "Home". cambium.inria.fr. Retrieved 7 October 2022.
17. ^ "OCaml compiler governance and membership". 2023.
18. ^ "OCaml governance and projects". 2023.
19. ^ "ocaml/asmcomp at trunk · ocaml/ocaml · GitHub". GitHub. Retrieved 2 May 2015.
20. ^ A domain is a unit of parallelism in OCaml, a domain usually corresponds to a CPU core
21. ^ "OCaml - The toplevel system or REPL (ocaml)". ocaml.org. Retrieved 17 May 2021.
22. ^ "OCaml - Batch compilation (Ocamlc)".
23. ^ "3.7. Options — OCaml Programming: Correct + Efficient + Beautiful". cs3110.github.io. Retrieved 7 October 2022.
24. ^ oleg-at-okmij.org. "BER MetaOCaml". okmij.org.
25. ^ EasyCrypt/easycrypt, EasyCrypt, 5 July 2024, retrieved 5 July 2024
26. ^ "Messenger.com Now 50% Converted to Reason · Reason". reasonml.github.io. Retrieved 27 February 2018.
27. ^ "Flow: A Static Type Checker for JavaScript". Flow. Archived from the original on 8 April 2022. Retrieved 10 February 2019.
28. ^ "Infer static analyzer". Infer.
29. ^ "WebAssembly/spec: WebAssembly specification, reference interpreter, and test suite". World Wide Web Consortium. 5 December 2019. Retrieved 14 May 2021 - via GitHub.
30. ^ "Companies using OCaml". OCaml.org. Retrieved 14 May 2021.
31. ^ "BuckleScript: The 1.0 release has arrived! | Tech at Bloomberg". Tech at Bloomberg. 8 September 2016. Retrieved 21 May 2017.
32. ^ Scott, David; Sharp, Richard; Gazagnaire, Thomas; Madhavapeddy, Anil (2010). Using functional programming within an industrial product group: perspectives and perceptions. International Conference on Functional Programming. Association for Computing Machinery. doi:10.1145/1863543.1863557.
33. ^ "Flow on GitHub". GitHub. 2023.
34. ^ Yaron Minsky (1 November 2011). "OCaml for the Masses". Retrieved 2 May 2015.
35. ^ Yaron Minsky (2016). "Keynote - Observations of a Functional Programmer". ACM Commercial Uses of Functional Programming.
36. ^ Yaron Minsky (2023). "Signals & Threads" (Podcast). Jane Street Capital.
37. ^ Anil Madhavapeddy (2016). "Improving Docker with Unikernels: Introducing HyperKit, VPNKit and DataKit". Docker, Inc.
38. ^ "VPNKit on GitHub". GitHub. 2023.

## External links

[edit]

Wikibooks has a book on the topic of: OCaml

* Official website
* OCaml manual
* OCaml Package Manager
* Real World OCaml

* v
* t
* e

ML programming

Software|

| Implementations,
dialects|

| Caml|

* OCaml°
* Eff
* F*°
* F#°
* JoCaml°
* Reason°

|

Standard ML|

* Alice°
* Concurrent ML
* Extended ML
* MLton°
* Standard ML of New Jersey° (SML/NJ)

Dependent ML|

* ATS°

* Futhark°
* Lazy ML
* MacroML
* Ur°

Programming tools|

* Alt-Ergo°
* Astrée
* Camlp4°
* FFTW°
* Frama-C°
* Haxe°
* Marionnet°
* MTASC°
* Poplog°
* Semgrep°
* SLAM project

Theorem provers,
proof assistants|

* Coq°
* HOL°
* HOL Light°
* Isabelle°
* LEGO
* Logic for Computable Functions
* Matita°
* Twelf°

* GeneWeb°

Community|

| Designers|

* Lennart Augustsson (Lazy ML)
* Damien Doligez (OCaml)
* Gérard Huet (Caml)
* Xavier Leroy (Caml, OCaml)
* Robin Milner (ML)
* Don Sannella (Extended ML)
* Don Syme (F#)

|

* Thierry Coquand
* Steven G. Johnson
* Christine Paulin-Mohring
* Frank Pfenning
* Simon Thompson

* Italics = discontinued
* ° = Open-source software
Book Category:Family:ML Category:Family:OCaml Category:Software:OCaml

* v
* t
* e

Programming languages

* Comparison
* Timeline
* History

* Ada
* ALGOL
* Simula
* APL
* Assembly
* BASIC
* Visual Basic
* classic
* .NET
* C
* C++
* C#
* COBOL
* Erlang
* Forth
* Fortran
* Go
* Haskell
* Java
* JavaScript
* Julia
* Kotlin
* Lisp
* Lua
* MATLAB
* ML
* Pascal
* Object Pascal
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* SQL
* Scratch
* Shell
* Smalltalk
* Swift
* more...

* Lists: Alphabetical
* Categorical
* Generational
* Non-English-based
* Category

Authority control databases

International|

* VIAF

National|

* Germany
* United States
* Norway
* Israel

*[v]: View this template
*[t]: Discuss this template
*[e]: Edit this template