Difference between revisions 123732099 and 125156110 on eswiki

< previous diff
next diff >
Ocaml
El lenguaje '''Objective CAML''', también llamado '''Ocaml''' u '''O'Caml''', el nombre proviene de las siglas en inglés '''O'''bjective '''C'''ategorical '''A'''bstract '''M'''achine '''L'''anguage. Es un lenguaje de programación avanzado de la familia de los lenguajes [[ML_(lenguaje_de_programación)|ML]], desarrollado y distribuido por el [[INRIA]] en [[Francia]]. Ocaml
admite los paradigmas de [[programación imperativa]], [[programación funcional]] y [[programación orientada a objetos]].

Ocaml nace de la evolución del lenguaje CAML, abreviación de ''[[Categorical Abstract Machine Language]]'', al integrársele la programación con objetos.

El código fuente en Ocaml se compila en código para una máquina virtual o en código de máquina para diferentes arquitecturas. Este último compilador produce código comparable en eficiencia al producido por compiladores como el del lenguaje [[Lenguaje de programación C|C]]/[[C++]].

Ocaml dispone de un análisis de tipos estático con inferencia de tipos, con valores funcionales de primera clase, [[polimorfismo parametrizado]], [[llamada por patrones]], [[manejo de excepciones]], [[recolección de basura]] y otras características avanzadas.

== Ejemplos de código ==
=== "Hola Mundo" ===
<pre>
 > print_endline "Hello World !" ;;
 Hello World !
 val () : unit = <fun>
 >
</pre>
Éste es un ejemplo de uso del entorno de ejecución (el símbolo de entrada de datos es el ">").

=== Manipulación de listas ===
<pre>
  (* Listas genéricas *)
  
  (* Longitud de una lista *)
  let rec long  = function
    |[] -> 0
    |x::xs -> 1 + long xs;;
 
  (* Ordenamiento por inserción *)
  (* dada una relación de orden *)
  let rec ordenar = function
    |[] -> []
    |x::xs -> insertar x (ordenar xs)
  and insertar e = function
    |[] -> [e]
    |x::xs -> if x > e 
              then e::x::xs 
              else x::(insertar e xs);;

  # let l = ["La"; "vida"; "es"; "un"; "largo"; "y"; "tranquilo"; "río"];;
  - : string list =
  ["La"; "vida"; "es"; "un"; "largo"; "y"; "tranquilo"; "río"]

  # long l;;
  - : int = 8

  # ordenar l;;
  - : string list =
  ["La"; "es"; "largo"; "río"; "tranquilo"; "un"; "vida"; "y"]
</pre>
=== Árboles ===
<pre>
 
  (* Definición de un árbol binario, para cualquier tipo 'a *)
  type 'a arbol = AVac | Nodo of ('a arbol * 'a * 'a arbol);;

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

=== Funciones locales y alcance de variables ===
<pre>
 let elefantes n =
   let rec companneros m = 
      if m<=n then begin
         print_int m;
         print_string " Elefantes, se balanceaban, sobre la tela de una araña.\n";
         print_string "Como veían, que resistía, fueron a buscar a un camarada.\n";
         companneros (m+1)
    end in
      print_string "1 Elefante, se balanceaba, sobre la tela de una araña.\n";
      print_string "Como veía, que resistía, se fue a buscar a un camarada.\n";
      companneros 2
  ;;
  elefantes 99 ;;
</pre>

=== Más ejemplos en el intérprete ===

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

 > let o = object   val x = 3     method f y = x + y    end;;
 val o :  < f  : int -> int > = <obj>
 > let u x y = x#f y ;;
 val u : < f : 'a -> 'b; .. > -> 'a -> 'b = <fun>
 > u o 4 ;;
 - : int = 7
 > class add i =
   object
       val mutable x = i
       method f y = x + y
       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
 > (u more 4) + (u o 5) ;;
 - : int = 15
 > more#set 6 ;;
 - : unit = ()

== Derivación de tipos ==
'''Tipos básicos:'''

* int: enteros, comprendidos entre min_int y max_int.
* float: reales en coma flotante.
* bool: valores lógicos { true / false }
* char: caracteres del código ASCII. Por ejemplo: ‘a’ (comillas simples).
* string: cadenas de chars. Por ejemplo: “a” (comillas dobles). La cadena más simple es la vacía: “”.

Ocaml es '''fuertemente tipado''' es decir que toda expresión tiene un tipo único y sólo pueden aplicarse valores a funciones cuando el tipo del valor corresponde al tipo esperado por la función. Por ejemplo (+) es la función que suma dos enteros, mientras (+.) es la que que suma dos flotantes (en general los operadores entre enteros tienen una análogo para flotantes cuyo nombre termina con el carácter punto).

La ventaja de este tipado es la posibilidad de derivar automáticamente el tipo de expresiones (librando al programador de esa tarea). Por ejemplo una expresión como fun y -> y +. y es una función que recibe un flotante y retorna un flotante, lo derivamos sabiendo que (+.) recibe dos flotantes y retorna un flotante.

'''Algunos operadores habituales:'''

* Para int: + -- * /
* Para float: +. -. *. /. (* igual que en los int, pero seguidos de un punto. En Ocaml no se sobrecargan los nombres, por eso no se llama de igual forma la suma de enteros que la de reales *)
* Para bool: && (conjunción) || (disyunción)
* Para string: ^ (concatenación)

El motor de tipos de Ocaml infiere los tipos, y si un tipo es desconocido o no se puede inferir, lo representa como alfa, beta, etc. Dado que el compilador no puede mostrar letras griegas en pantalla, se referirá a ellas con la letra correspondiente precedida de un apóstrofe: ‘a, ‘b, ‘c, etc.

Por eso Ocaml es un lenguaje de programación funcional con cuatro características básicas:

Está fuertemente “tipado“: (Cualquier dato es de un tipo conocido).
El “tipaje” es estático :Todos los tipos existen. No se crean nuevos.
Las expresiones se evalúan de forma “eager” :(estricta o completa, es decir, se evalúan todas las entradas/salidas posibles)

== Tipos de compiladores ==
En cuanto a interpretación/compilación se basa en un modelo de máquina abstracta portable (máquina Zinc). Cuenta con un intérprete (ocaml) que es a su vez un entorno interactivo útil para experimentar y dos compiladores:

* ocalm: También llamado ‘top-level’, compilador interactivo (a tiempo real)
* ocamlc: También llamado ‘batch_compiler’, compilador “batch” (por lotes). Genera código ocaml. Genera bytecode utilizable por la máquina Zinc y portable a toda arquitectura donde se ha portado la máquina Zinc (incluyendo x386/OpenBSD, x386/Linux, x386/Windows 95-NT, Mac, Digital, Solaris, IRIX).
* ocamlrun: También llamado ‘runtime’, máquina que ejecuta código compilado.
* ocamlopt: También llamado ‘batch_compiler’, compilador optimizado. Genera código nativo o máquina (para el sistema en el que se está trabajando). Los archivos compilados con ocamlopt suelen ser más grandes que con ocaml. Genera binarios para diversas arquitecturas (incluyendo [[procesadores i386 con sistemas operativos OpenBSD y Linux).

Una diferencia entre ocaml y ocamlc, por ejemplo, si se indica una misma instrucción, en ocaml se ejecutará y mostrará por pantalla su resultado, mientras que con ocamlc se ejecutará pero no se verá nada.

== Versiones ==
* ocaml-1.07 (12-Dic-2001 7:30)
* ocaml-2.02 (12-Dic-2001 7:27)
* ocaml-2.04 (12-Dic-2001 7:27)
* ocaml-2.99-alpha (12-Dic-2001 19:31)
* ocaml-3.00 (12-Dic-2001 7:28)
* ocaml-3.01 (12-Dic-2001 7:28)
* Ocaml-3.02 (12-Dic-2001 7:28)
* Ocaml-3.03-alpha (12-Dic-2001 7:28)
* ocaml-3.04 (20-Ago-2002 09:42)
* ocaml-3.05-beta ( 20-Ago-2002 09:42)
* ocaml-3.06 (24-May-2003 12:20)
* ocaml-3.07 (14-Mar-2005 15:19)
* ocaml-3.07-beta1 (22-Jul-2003 10:42)
* ocaml-3.07-beta2 (26- Ago -2003 09:55)
* ocaml-3.07pl2 (14-Mar-2005 15:19)
* ocaml-3.08 (18-Ago-2005 5:40)
* ocaml-3.09 (22-Sep-2006 11:20)
* ocaml-3.10 (10-Mar-2008 3:14)
* ocaml-3.11 (22-Ene-2010 4:08)
* ocaml-3.12 (29-Ago-2011 7:32)⏎
* ocaml-6.75 (engendrado cuando dos lesbianas se chupaban los senos <las dos eran shakira y jlo>)

== Referencias ==
{{listaref}}

== Enlaces externos ==
* [http://www.ocaml.org Sitio oficial de O'Caml en el INRIA] (en inglés)
* [http://try.ocamlpro.com/ Tratar en su navegador] (en inglés y francés)
* [http://www.ocaml-tutorial.org/ tutorial de Ocaml (INRIA)]
* [http://www.pps.jussieu.fr/Livres/ora/DA-OCAML/index.html ''Développement d'applications avec Objective Caml''], libro en línea (en francés).
* [https://www.ecured.cu/Ocalm#Caracter.C3.ADsticas ''EcuRed - Ocalm'']

{{Control de autoridades}}
[[Categoría:Lenguajes de programación imperativa]]
[[Categoría:Lenguajes de programación orientada a objetos]]
[[Categoría:Programación funcional]]
[[Categoría:Software de 1996]]