A linguaxe **Objective CAML**, tamén chamado **Ocaml** ou **O'Caml**, é unha linguaxe de programación avanzada da familia das linguaxes ML, desenvolvida e distribuída polo INRIA en Francia. Ocaml admite os paradigmas de programación imperativa, programación funcional e programación orientada a obxectos.

Ocaml nace da evolución da linguaxe CAML, abreviación de *Categorical Abstract Machine Language*, ao integrárselle a programación con obxectos.

O código fonte en Ocaml se compila en código para unha máquina virtual ou en código de máquina para diferentes arquitecturas. Este último compilador produce código comparable en eficiencia ao producido por compiladores como o da linguaxe C/C++.

Ocaml dispón dunha análise de tipos estático con inferencia de tipos, con valores funcionais de primeira clase, polimorfismo parametrizado, chamada por patróns, manexo de excepcións, recolección de lixo e outras características avanzadas.

Exemplos de código
------------------

### "Ola Mundo"

```
 > print_endline "Ola, mundo !" ;;
 Ola, mundo !
 val () : unit = <fun>
 >

```

Este é un exemplo de uso da contorna de execución (o símbolo de entrada de datos é o ">").

### Manipulación de listas

```
  (* Listas xenéricas *)
 
  (* Lonxitude dunha lista *)
  let rec long  = function
    |[] -> 0
    |x::xs -> 1 + long xs;;
 
  (* Ordenamento por inserción *)
  (* dada unha relación de orde *)
  let rec ordenar = function
    |[] -> []
    |x::xs -> inserir x (ordenar xs)
  and inserir e = function
    |[] -> [e]
    |x::xs -> if x > e
              then e::x::xs
              else x::(inserir e xs);;

  # let l = ["A"; "vida"; "é"; "un"; "longo"; "e"; "tranquilo"; "río"];;
  - : string list =
  ["A"; "vida"; "é"; "un"; "longo"; "e"; "tranquilo"; "río"]

  # long l;;
  - : int = 8

  # ordenar l;;
  - : string list =
  ["A"; "é"; "longo"; "río"; "tranquilo"; "un"; "vida"; "e"]

```

### Árbores

```
 
  (* Definición dunha árbore binaria, para calquera tipo 'a ). *
  type 'a arbol = AVac | Nodo of ('a arbol * 'a 'a arbol);;. *

  let a = Nodo(AVac, 4, Nodo(AVac, 2, AVac));;
 
  (* Altura da árbore *)
  let rec altura = function
    |AVac -> 0
    |Nodo(i, _, d) -> 1 + max (altura i) (altura d)  ;;
 
  # altura a;;
  - : int = 2

```

### Funcións locais e alcance de variables

```
 let elefantes n =
   let rec companneros m =
      if m<=n then begin
         print_int m;
         print_string "5 elefantes bambeaban sobre a tea dunha araña.@n/*n";
         print_string "Como vían que resistía, foron buscar un camarada.@n/*n";
         companneros (m+1)
    end in
      print_string "1 elefante bambeaba sobre a tea dunha araña.@n/*n";
      print_string "Como vía que resistía, foi buscar un camarada.@n/*n";
      companneros 2
  ;;
  elefantes 99 ;;

```

### Máis exemplos no intérprete

```
> let f x e = x + e ;;
val f : int -> int -> int = <fun>
> f 3 4 ;;
- 7 : int = <fun>
> let g x = f 3 ;;
val g : int -> int = <fun>
> g 9 ;;
- 12 : int = <fun>
```

```
> let ou =object   val x= 3     method f e = x + e    end;;
val ou :  < f  : int -> int > = <obj>
> let ou x e = x#f e ;;
val ou : < f : 'a -> 'b; .. > -> 'a -> 'b = <fun>
> ou ou 4 ;;
- : int = 7
> class add i =
  object
      val mutable x = i
      method f e = x + e
      method set k = x <- k
  end
  ;;
class add :
  int ->
  object
   val mutable x : int
   method f : int -> int
   method set : int -> unit
  end
> let more = new add 3 ;;
val more : add = obj
> (ou more 4) + (ou ou 5) ;;
- : int = 15
> more#set 6 ;;
- : unit = ()
```

Notas
-----

1. ↑  A brief history of Caml (as I remember it)

Ligazóns externas
-----------------

* Sitio oficial de Ou'Caml no INRIA (en inglés)
* tutorial de Ocaml (INRIA)
* *Développement d'applications avec Objective Caml*, libro en liña (en francés).
* A brief history of Caml (as I remember it)

| * v
* c
* e
Linguaxes de programación |
| --- |
| Baixo nivel | 

|  |  |
| --- | --- |
| Primeira xeración | Código máquina |
| Segunda xeración | Assembly |

 |
| Alto nivel | 

|  |  |
| --- | --- |
| Terceira xeración | 
* A+
* ABC
* Algol
* B
* BASIC
* C
* C++
* C#
* COBOL
* CPL
* D
* E
* Fortran
* Go
* Java
* JavaScript
* Lisp
* Objective-C
* PL/1
* Pascal
* Smalltalk
* Visual Basic .NET

 |
| Cuarta xeración | 
* Clarion
* Clipper
* Clojure
* Common Lisp
* Erlang
* GNU Octave
* Haskell
* Lisp
* Lua
* Julia
* Perl
* PHP
* Prolog
* Python
* R
* Ruby
* Rust
* S
* Scilab
* Stata
* SQL

 |
| Quinta xeración | 
* Mercury
* OPS5
* Prolog

 |

 |
| 
* Ambiente de desenvolvemento
* Metaprogramación
* Programación a nivel funcional
* Programación estruturada
* Programación non estruturada
* Programación imperativa
* Programación modular
* Programación multidimensional
* Orientación a obxectos

 |

|  |  |
| --- | --- |
| Control de autoridades | 
* Wd: Q212587
* WorldCat
* VIAF: 8149106282068492326
* BIBSYS: 10016856
* GND: 7578649-7
* LCCN: sh2007000473

 |