View source for Caml

{{Short description|Programming language}}
{{About|the programming language||CAML (disambiguation)}}
{{Use dmy dates|date=April 2024}}
{{Infobox programming language
| name = Caml
| logo = Caml.gif
| paradigm = [[Multi-paradigm programming language|Multi-paradigm]]: [[Functional programming|functional]], [[Imperative programming|imperative]]
| family = [[ML (programming language)|ML]]
| designer = [[Gérard Huet]], Guy Cousineau, Ascánder Suárez, Pierre Weis, Michel Mauny (Heavy Caml), [[Xavier Leroy]] (Caml Light)
| developer = [[French Institute for Research in Computer Science and Automation|INRIA]], [[École normale supérieure (Paris)|ENS]]
| released = {{Start date and age|1985}}
| latest release version = 0.75<ref>{{cite web |title=Latest Caml Light release |url=http://caml.inria.fr/caml-light/release.en.html |access-date=22 February 2020}}</ref>
| latest release date = {{Start date and age|2002|01|26}}
| latest preview version = 
| latest preview date = 
| typing = [[Type inference|inferred]], [[Static typing|static]], [[Strong and weak typing|strong]]
| memory management = [[Garbage collection (computer science)|automatic]]
| operating system = [[Cross-platform software|Cross-platform]]: [[Unix]], [[Linux]], [[macOS]]; [[Microsoft Windows|Windows]]
| license = [[Q Public License|QPL]] 1, [[GNU Lesser General Public License|LGPL]] 2 (Caml Light)
| website = {{URL|caml.inria.fr}}
| dialects = 
| influenced by = [[ML (programming language)|ML]]
| influenced = [[OCaml]]
}}

'''Caml''' (originally an acronym for '''Categorical Abstract Machine Language''') is a [[Multi-paradigm programming language|multi-paradigm]], [[General-purpose programming language|general-purpose]], [[High-level programming language|high-level]], [[Functional programming|functional]] [[programming language]] which is a [[Dialect (computing)|dialect]] of the [[ML (programming language)|ML programming language]] family. Caml was developed in France at [[French Institute for Research in Computer Science and Automation]] (INRIA) and [[École normale supérieure (Paris)]] (ENS).

Caml is statically [[Type system|typed]], [[Strict evaluation|strictly evaluated]], and uses [[Garbage collection (computer science)|automatic memory management]]. [[OCaml]], the main descendant of Caml, adds many features to the language, including an [[object-oriented programming]] (object) layer.

==Examples==
In the following, {{OCaml|#}} represents the Caml prompt.

===Hello World===
A [["Hello, World!" program]] is:
<syntaxhighlight lang="ocaml">
print_endline "Hello, world!";;
</syntaxhighlight>

===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:
<syntaxhighlight lang=OCaml>
let rec fact n = if n=0 then 1 else n * fact(n - 1);;
</syntaxhighlight>
The function can be written equivalently using [[pattern matching]]:
<syntaxhighlight lang=OCaml>
let rec fact = function
  | 0 -> 1
  | n -> n * fact(n - 1);;
</syntaxhighlight>
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 {{OCaml|int -> int}}, meaning that this function maps ints onto ints. For example, 12! is:
<syntaxhighlight lang=OCaml>
 # fact 12;;
 - : int = 479001600
</syntaxhighlight>

===Numerical derivative (higher-order functions)===
Since Caml is a [[functional programming]] language, it is easy to create and pass around functions in Caml programs. This ability has very many applications. Calculating the numerical derivative of a function is one example. The following Caml function {{OCaml|d}} computes the numerical derivative of a given function {{OCaml|f}} at a given point {{OCaml|x}}:
<syntaxhighlight lang=OCaml>
let d delta f x =
  (f (x +. delta) -. f (x -. delta)) /. (2. *. delta);;
</syntaxhighlight>
This function requires a small value {{OCaml|delta}}. A good choice for delta is the cube root of the [[machine epsilon]].{{Citation needed|date=May 2008}}.

The type of the function {{OCaml|d}} indicates that it maps a {{OCaml|float}} onto another function with the type {{OCaml|(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 {{OCaml|delta}} to {{OCaml|d}}, to obtain a more specialised function:
<syntaxhighlight lang=OCaml>
# let d = d (sqrt epsilon_float);;
val d : (float -> float) -> float -> float = <fun>
</syntaxhighlight>
Note that the inferred type indicates that the replacement {{OCaml|d}} is expecting a function with the type {{OCaml|float -> float}} as its first argument. We can compute a numerical approximation to the derivative of <math>x^3 - x - 1</math> at <math>x=3</math> with:
<syntaxhighlight lang=OCaml>
# d (fun x -> x *. x *. x -. x -. 1.) 3.;;
- : float = 26.
</syntaxhighlight>
The correct answer is <math>f'(x) = 3x^2 - 1 \rightarrow f'(3) = 27 - 1 = 26</math>.

The function {{OCaml|d}} is called a "[[higher-order function]]" because it accepts another function ({{OCaml|f}}) as an argument.
Going further can create the (approximate) derivative of f, by applying {{OCaml|d}} while omitting the {{OCaml|x}} argument:
<syntaxhighlight lang=OCaml>
# let f' = d (fun x -> x *. x *. x -. x -. 1.) ;;
val f' : float -> float = <fun>
</syntaxhighlight>

The concepts of curried and higher-order functions are clearly useful in mathematical programs. 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]] [[discrete wavelet transform|transform]] of an [[integer]]-power-of-two-length 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 ({{OCaml|h1}} and {{OCaml|h2}}) off the front and storing their sums and differences on the lists {{OCaml|s}} and {{OCaml|d}}, respectively:
<syntaxhighlight lang=OCaml>
# 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>
</syntaxhighlight>
For example:
<syntaxhighlight lang=OCaml>
  # haar [1; 2; 3; 4; -4; -3; -2; -1];;
   - : int list = [0; 20; 4; 4; -1; -1; -1; -1]
</syntaxhighlight>
Pattern matching allows complicated transformations to be represented clearly and succinctly. Moreover, the Caml 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.&nbsp;210.).

==History==
The first Caml implementation was written in [[Lisp (programming language)|Lisp]] by Ascánder Suárez in 1987 at the [[French Institute for Research in Computer Science and Automation]] (INRIA).<ref name=INRIA>[https://caml.inria.fr/about/history.en.html "A History of Caml"], inria.fr</ref>

Its successor, ''Caml Light'', was implemented in [[C (programming language)|C]] by [[Xavier Leroy]] and [[Damien Doligez]],<ref name=INRIA/> and the original was nicknamed "Heavy Caml" because of its higher memory and CPU requirements.<ref name=INRIA/>

''Caml Special Light'' was a further complete rewrite that added a powerful module system to the core language. It was augmented with an [[object-oriented programming]] (object) layer to become ''Objective Caml'', eventually renamed [[OCaml]].

==See also==
*[[Categorical abstract machine]]
*[[OCaml]]

==References==
{{Reflist}}

==Bibliography==
*[http://pauillac.inria.fr/cousineau-mauny/main.html The Functional Approach to Programming with Caml] {{Webarchive|url=https://web.archive.org/web/20071224205843/http://pauillac.inria.fr/cousineau-mauny/main.html |date=2007-12-24}} by Guy Cousineau and Michel Mauny.
*Cardelli, Luca (1984). [https://dx.doi.org/10.1145/800055.802037 Compiling a functional language] ''ACM Symposium on LISP and functional programming'', Association of Computer Machinery.

==External links==
*{{Official website|caml.inria.fr}}, INRIA

{{ML programming}}
{{Programming languages}}

[[Category:Programming languages]]
[[Category:High-level programming languages]]
[[Category:Functional languages]]
[[Category:ML programming language family]]
[[Category:Programming languages created in 1985]]
[[Category:French inventions]]