Ocaml

lenguaje de programación
(Redirigido desde «OCaml»)

El lenguaje Objective CAML, también llamado Ocaml u O'Caml, el nombre proviene de las siglas en inglés Objective Categorical Abstract Machine Language. Es un lenguaje de programación avanzado de la familia de los lenguajes 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 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ódigoEditar

"Hola Mundo"Editar

 > print_endline "Hello World !" ;;
 Hello World !
 val () : unit = <fun>
 >

Éste es un ejemplo de uso del entorno de ejecución (el símbolo de entrada de datos es el ">").

Manipulación de listasEditar

  (* 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"]

ÁrbolesEditar

 
  (* 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

Funciones locales y alcance de variablesEditar

 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 ;;

Más ejemplos en el intérpreteEditar

> 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 tiposEditar

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 compiladoresEditar

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.

VersionesEditar

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

ReferenciasEditar

Enlaces externosEditar