Caml
Paradigm  multiparadigm: functional, imperative; objectoriented in OCaml 

Designed by  Gérard Huet, Guy Cousineau, Ascánder Suárez, Pierre Weis, Michel Mauny (Heavy Caml), Xavier Leroy (Caml Light, OCaml) 
First appeared  1985 
Stable release 
4.06.0^{[1]} / November 3, 2017

Typing discipline  strong, static, inferred 
OS  Crossplatform 
Website  caml 
Major implementations  
OCaml, Caml Light  
Influenced by  
ML  
Influenced  
F# 
Caml (originally an acronym for Categorical abstract machine language) is a multiparadigm, generalpurpose programming language which is a dialect of the ML programming language family. Caml was developed in France at INRIA and ENS.
Like many descendants of ML, Caml is statically typed, strictly evaluated, and uses automatic memory management.
OCaml, as of 2017^{[update]} the main implementation of Caml, adds many features to the language, including an object layer.
Contents
Examples
In the following, #
represents the OCaml prompt.
Hello World
print_endline "Hello, world!";;
Factorial function (recursion and purely functional programming)
Many mathematical functions, such as factorial, are most naturally represented in a purely functional form. The following recursive, purely functional Caml function implements factorial:
let rec fact n = if n=0 then 1 else n * fact(n  1);;
The function can be written equivalently using pattern matching:
let rec fact = function
 0 > 1
 n > n * fact(n  1);;
This latter form is the mathematical definition of factorial as a recurrence relation.
Note that the compiler inferred the type of this function to be int > int
, meaning that this function maps ints onto ints. For example, 12! is:
# fact 12;;
 : int = 479001600
Numerical derivative (higherorder functions)
Since OCaml is a functional programming language, it is easy to create and pass around functions in OCaml programs. This capability has an enormous number of applications. Calculating the numerical derivative of a function is one such application. The following Caml function d
computes the numerical derivative of a given function f
at a given point x
:
let d delta f x =
(f (x +. delta) . f (x . delta)) /. (2. *. delta);;
This function requires a small value delta
. A good choice for delta is the cube root of the machine epsilon^{[citation needed]}.
The type of the function d
indicates that it maps a float
onto another function with the type (float > float) > float > float
. This allows us to partially apply arguments. This functional style is known as currying. In this case, it is useful to partially apply the first argument delta
to d
, to obtain a more specialised function:
# let d = d (sqrt epsilon_float);;
val d : (float > float) > float > float = <fun>
Note that the inferred type indicates that the replacement d
is expecting a function with the type float > float
as its first argument. We can compute a numerical approximation to the derivative of at with:
# d (fun x > x *. x *. x . x . 1.) 3.;;
 : float = 26.
The correct answer is .
The function d
is called a "higherorder function" because it accepts another function (f
) as an argument. We can go further and create the (approximate) derivative of f, by applying d
while omitting the x
argument:
# let f' = d (fun x > x *. x *. x . x . 1.) ;;
val f' : float > float = <fun>
The concepts of curried and higherorder functions are clearly useful in mathematical programs. In fact, these concepts are equally applicable to most other forms of programming and can be used to factor code much more aggressively, resulting in shorter programs and fewer bugs.
Discrete wavelet transform (pattern matching)
The 1D Haar wavelet transform of an integerpoweroftwolength list of numbers can be implemented very succinctly in Caml and is an excellent example of the use of pattern matching over lists, taking pairs of elements (h1
and h2
) off the front and storing their sums and differences on the lists s
and d
, respectively:
# let haar l =
let rec aux l s d =
match l, s, d with
[s], [], d > s :: d
 [], s, d > aux s [] d
 h1 :: h2 :: t, s, d > aux t (h1 + h2 :: s) (h1  h2 :: d)
 _ > invalid_arg "haar"
in aux l [] [];;
val haar : int list > int list = <fun>
For example:
# haar [1; 2; 3; 4; 4; 3; 2; 1];;
 : int list = [0; 20; 4; 4; 1; 1; 1; 1]
Pattern matching allows complicated transformations to be represented clearly and succinctly. Moreover, the OCaml compiler turns pattern matches into very efficient code, at times resulting in programs that are shorter and faster than equivalent code written with a case statement(Cardelli 1984, p. 210.).
History
The first Caml implementation was written in Lisp, in 1987 by staff at French Institute for Research in Computer Science and Automation (INRIA)^{[2]}
Its successor, Caml Light, was implemented in C by Xavier Leroy and Damien Doligez^{[2]}  and the original was then retrospectively nicknamed "Heavy CAML" because of its higher memory and CPU requirements.^{[citation needed]}
CAML Special Light was a further complete rewrite^{[2]} that added a powerful (applicative) module system to the core language.
OCaml is currently the main implementation of Caml, and adds many new features to the language including an object layer.
See also
 Categorical abstract machine
 F#, an OCamllike language for the .NET Framework
 OCaml
 Standard ML
 Haskell (programming language)
References
External links
 Official website Caml language family
Bibliography
 The Functional Approach to Programming with Caml by Guy Cousineau and Michel Mauny.
 Cardelli, Luca (1984). Compiling a functional language ACM Symposium on LISP and functional programming, Association of Computer Machinery.