OCaml

Entre las décadas de 1970 y 1980, Robin Milner , un científico informático británico y ganador del Premio Turing , trabajó en el Laboratorio de Fundamentos de la Informática de la Universidad de Edimburgo . ^{[ 9 ] [ 10 ]} Milner y otros trabajaban en demostradores de teoremas , que históricamente se habían desarrollado en lenguajes como Lisp . Milner se topó repetidamente con el problema de que los demostradores de teoremas intentaban afirmar que una prueba era válida al juntar no-pruebas. ^{[ 10 ]} Como resultado, pasó a desarrollar el metalenguaje para su Lógica para Funciones Computables , un lenguaje que solo permitiría al escritor construir pruebas válidas con su sistema de tipos polimórfico. ^{[ 11 ]} ML se convirtió en un compilador para simplificar el uso de LCF en diferentes máquinas y, en la década de 1980, se convirtió en un sistema completo por sí mismo. ^{[ 11 ]} ML serviría finalmente como base para la creación de OCaml.

A principios de la década de 1980, se produjeron algunos avances que impulsaron al equipo Formel de INRIA a interesarse por el lenguaje ML. Luca Cardelli , profesor de investigación en la Universidad de Oxford , utilizó su máquina abstracta funcional para desarrollar una implementación más rápida de ML, y Robin Milner propuso una nueva definición de ML para evitar divergencias entre diversas implementaciones. Simultáneamente, Pierre-Louis Curien, investigador sénior en la Universidad Paris Diderot , desarrolló un cálculo de combinadores categóricos y lo vinculó con el cálculo lambda , lo que condujo a la definición de la máquina abstracta categórica (CAM). Guy Cousineau, investigador en la Universidad Paris Diderot, reconoció que esto podría aplicarse como método de compilación para ML. ^{[ 12 ]}

Caml fue diseñado y desarrollado inicialmente por el equipo Formel de INRIA, liderado por Gérard Huet . La primera implementación de Caml se creó en 1987 y se siguió desarrollando hasta 1992. Aunque fue Ascánder Suárez quien lo impulsó, Pierre Weis y Michel Mauny continuaron con el desarrollo después de que él se marchara en 1988. ^{[ 12 ]}

Se cita a Guy Cousineau recordando que su experiencia con la implementación de lenguajes de programación era inicialmente muy limitada, y que hubo múltiples deficiencias de las que él es responsable. A pesar de esto, cree que "Ascander, Pierre y Michel hicieron un trabajo bastante bueno". ^{[ 12 ]}

Entre 1990 y 1991, Xavier Leroy diseñó una nueva implementación de Caml basada en un intérprete de bytecode escrito en C. Además, Damien Doligez escribió un sistema de gestión de memoria, también conocido como recolector de basura secuencial , para esta implementación. ^{[ 11 ]} Esta nueva implementación, conocida como Caml Light , reemplazó a la antigua implementación de Caml y se ejecutaba en pequeñas máquinas de escritorio. ^{[ 12 ]} En los años siguientes, aparecieron bibliotecas como las herramientas de manipulación de sintaxis de Michel Mauny y ayudaron a promover el uso de Caml en equipos educativos y de investigación. ^{[ 11 ]}

En 1995, Xavier Leroy lanzó Caml Special Light, una versión mejorada de Caml. ^{[ 12 ]} Se añadió un compilador de código nativo optimizador al compilador de bytecode, lo que aumentó considerablemente el rendimiento hasta niveles comparables con lenguajes convencionales como C++ . ^{[ 11 ] [ 12 ]} Además, Leroy diseñó un sistema de módulos de alto nivel inspirado en el sistema de módulos de Standard ML, que proporcionaba potentes herramientas para la abstracción y la parametrización, y facilitaba la creación de programas de mayor envergadura. ^{[ 11 ]}

Didier Rémy y Jérôme Vouillon diseñaron un sistema de tipos expresivo para objetos y clases, que se integró en Caml Special Light. Esto dio lugar al desarrollo del lenguaje Objective Caml, lanzado por primera vez en 1996 y posteriormente renombrado como OCaml en 2011. Este sistema de objetos admitía notablemente muchos modismos de la programación orientada a objetos de forma estáticamente segura, mientras que esos mismos modismos causaban inestabilidad o requerían comprobaciones en tiempo de ejecución en lenguajes como C++ o Java . En 2000, Jacques Garrigue amplió Objective Caml con varias características nuevas, como métodos polimórficos, variantes y argumentos etiquetados y opcionales. ^{[ 11 ] [ 12 ]}

Se han añadido mejoras al lenguaje de forma incremental durante las últimas dos décadas para dar soporte a las crecientes bases de código comerciales y académicas en OCaml. ^{[ 11 ]} La versión OCaml 4.0 de 2012 añadió tipos de datos algebraicos generalizados (GADT) y módulos de primera clase para aumentar la flexibilidad del lenguaje. ^{[ 11 ]} La versión OCaml 5.0.0 de 2022 ^{[ 13 ]} es una reescritura completa del entorno de ejecución del lenguaje, eliminando el bloqueo global del recolector de basura y añadiendo manejadores de efectos mediante continuaciones delimitadas . Estos cambios permiten el soporte para el paralelismo de memoria compartida y la concurrencia sin distinción de color , respectivamente.

El desarrollo de OCaml continuó dentro del equipo Cristal en INRIA hasta 2005, cuando fue sucedido por el equipo Gallium. ^{[ 14 ]} Posteriormente, Gallium fue sucedido por el equipo Cambium en 2019. ^{[ 15 ] [ 16 ]} A partir de 2023, hay 23 desarrolladores principales de la distribución del compilador de una variedad de organizaciones ^{[ 17 ]} y 41 desarrolladores para el ecosistema más amplio de herramientas y empaquetado de OCaml. ^{[ 18 ]} En 2023, el compilador OCaml fue reconocido con el premio ACM SIGPLAN's Programming Languages ​​Software Award .

El siguiente programa "hello.ml":

print_endline "¡Hola mundo!"

se puede ejecutar directamente:

$ ocaml hello.ml

compilado en un ejecutable de código de bytes :

$ ocamlc hello.ml -o hello

o compilado en un ejecutable de código nativo optimizado :

$ ocamlopt hello.ml -o hello

y ejecutado:

$ ./hola ¡Hola mundo! $

El primer argumento de ocamlc, "hello.ml", especifica el archivo fuente a compilar y la bandera "-o hello" especifica el archivo de salida. ^{[ 22 ]}

El optionconstructor de tipos en OCaml, similar al Maybetipo en Haskell , aumenta un tipo de datos dado para devolver Someun valor del tipo de datos dado, o para devolver None. ^{[ 23 ]} Esto se utiliza para expresar que un valor puede estar presente o no.

# Algunos 42 ;; - : int opción = Algunos 42 # Ninguno ;; - : ' una opción = Ninguno

Este es un ejemplo de una función que extrae un entero de una opción, si lo hay, y lo convierte en una cadena , o, si no, devuelve una cadena vacía:

let extract o = match o with | Some i -> string_of_int i | None -> "" ;;

# extraer ( Algunos 42 );; - : cadena = "42" # extraer Ninguno ;; - : cadena = ""

Las listas son uno de los tipos de datos fundamentales en OCaml. El siguiente ejemplo de código define una función recursiva llamada `sum` que acepta un argumento, `integers` , que se supone que es una lista de enteros. Nótese la palabra clave ` recrecursiva`, que indica que la función es recursiva. La función itera recursivamente sobre la lista de enteros dada y proporciona la suma de sus elementos. La instrucción `match` tiene similitudes con el elemento ` switch` de C , aunque es mucho más general.

let rec sum integers = (* La palabra clave rec significa 'recursivo'. *) match integers with | [] -> 0 (* Devuelve 0 si integers es la  lista vacía []. *) | first :: rest -> first + sum rest ;; (* Llamada recursiva si integers es una  lista no vacía; first es el primer  elemento de la lista y rest es una  lista con el resto de los elementos,  posiblemente []. *)

# suma [ 1 ; 2 ; 3 ; 4 ; 5 ];; - : int = 15

Otra forma es utilizar la función de plegado estándar que funciona con listas.

let sum integers = List . fold_left ( fun accumulator x -> accumulator + x ) 0 integers ;;

# suma [ 1 ; 2 ; 3 ; 4 ; 5 ];; - : int = 15

Dado que la función anónima es simplemente la aplicación del operador +, esto se puede abreviar a:

sea ​​suma enteros = Lista . fold_left (+) 0 enteros

Además, se puede omitir el argumento de lista haciendo uso de una aplicación parcial :

sea ​​suma = Lista . fold_left (+) 0

OCaml se presta a expresar algoritmos recursivos de forma concisa. El siguiente ejemplo de código implementa un algoritmo similar a quicksort que ordena una lista en orden ascendente.

let rec qsort = function | [] -> [] | pivot :: rest -> let is_less x = x < pivot in let left , right = List . partition is_less rest in qsort left @ [ pivot ] @ qsort right

O bien, utilizando la aplicación parcial del operador >=.

let rec qsort = function | [] -> [] | pivot :: rest -> let is_less = (>=) pivot in let left , right = List . partition is_less rest in qsort left @ [ pivot ] @ qsort right

El siguiente programa calcula el número más pequeño de personas en una habitación para las cuales la probabilidad de cumpleaños completamente únicos es menor al 50% (el problema del cumpleaños , donde para 1 persona la probabilidad es 365/365 (o 100%), para 2 es 364/365, para 3 es 364/365 × 363/365, etc.) (respuesta = 23).

sea ​​year_size = 365 .let rec birthday_paradox prob people = let prob = ( year_size -. float people ) /. year_size *. prob in if prob < 0 . 5 then Printf . printf "answer = %d \n " ( people + 1 ) else birthday_paradox prob ( people + 1 ) ;;paradoja_del_cumpleaños 1 . 0 1

El siguiente código define una codificación Church de números naturales , con sucesor (succ) y suma (add). Un numeral Church nes una función de orden superior que acepta una función fy un valor , xy se aplica fexactamente veces. Para convertir un numeral Church de un valor funcional a una cadena, le pasamos una función que antepone la cadena a su entrada y la cadena constante . El ejemplo dado muestra el numeral Church para cinco como “SSSSS0”.xn"S""0"

let zero f x = x let succ n f x = f ( n f x ) let one = succ zero let two = succ ( succ zero ) let add n1 n2 f x = n1 f ( n2 f x ) let to_string n = n ( fun k -> "S" ^ k ) "0" let church_5 = to_string ( add ( succ two ) two ) ;; print_endline church_5 ;

OCaml ofrece acceso directo a diversas bibliotecas. Por ejemplo, incluye una biblioteca integrada para aritmética de precisión arbitraria . Dado que la función factorial crece muy rápidamente, supera con facilidad los límites de los números de precisión de máquina (normalmente de 32 o 64 bits). Por lo tanto, la función factorial resulta idónea para la aritmética de precisión arbitraria.

En OCaml, el módulo Num (ahora reemplazado por el módulo ZArith) proporciona aritmética de precisión arbitraria y se puede cargar en un nivel superior en ejecución usando:

# # usar "topfind" ;; # # requerir "num" ;; # abrir Num ;;

La función factorial se puede escribir entonces utilizando los operadores numéricos de precisión arbitraria =/ , */ y -/ : 

# let rec fact n = if n =/ Int 0 then Int 1 else n */ fact ( n -/ Int 1 );; val fact : Num . num -> Num . num = < fun >

Esta función puede calcular factoriales mucho mayores, como 120!:

# cadena_de_num ( hecho ( Int 120 ));; - : cadena = "6689502913449127057588118054090372586752746333138029810295671352301633 55724496298936687416527198498130815763789321409055253440858940812185989 8481114389650005964960521256960000000000000000000000000000"

El siguiente programa renderiza un triángulo giratorio en 2D usando OpenGL :

let () = ignore ( Glut . init Sys . argv ); Glut . initDisplayMode ~ double_buffer : true () ; ignore ( Glut . createWindow ~ title : "OpenGL Demo" ); let angle t = 10 . *. t *. t in let render () = GlClear . clear [ ` color ]; GlMat . load_identity () ; GlMat . rotate ~ angle : ( angle ( Sys . time () )) ~ z : 1 . () ; GlDraw . begins ` triangles ; List . iter GlDraw . vertex2 [- 1 ., - 1 .; 0 ., 1 .; 1 ., - 1 .]; GlDraw . ends () ; Glut . swapBuffers () en GlMat . modo ` modelview ; Glut . displayFunc ~ cb : render ; Glut . idleFunc ~ cb :( Some Glut . postRedisplay ); Glut . mainLoop ()

Se requieren las bibliotecas LablGL para OpenGL. El programa se puede compilar a código de bytes con:

$ ocamlc -I +lablGL lablglut.cma lablgl.cma simple.ml -o simple

o a nativecode con:

$ ocamlopt -I +lablGL lablglut.cmxa lablgl.cmxa simple.ml -o simple

o, más sencillamente, utilizando el comando de compilación ocamlfind.

$ ocamlfind opt simple.ml -package lablgl.glut -linkpkg -o simple

y correr:

$ ./simple

En OCaml se pueden desarrollar programas gráficos 2D y 3D mucho más sofisticados y de alto rendimiento. Gracias al uso de OpenGL y OCaml, los programas resultantes pueden ser multiplataforma, compilándose sin necesidad de modificaciones en muchas de las principales plataformas.

El siguiente código calcula la secuencia de Fibonacci de un número n dado como entrada. Utiliza recursión de cola y coincidencia de patrones.

sea ​​fib n = sea rec fib_aux m a b = coincidir m con | 0 -> a | _ -> fib_aux ( m - 1 ) b ( a + b ) en fib_aux n 0 1

Las funciones pueden recibir otras funciones como entrada y devolver otras funciones como resultado. Por ejemplo, aplicar dos veces a una función f produce una función que aplica f dos veces a su argumento.

let twice ( f : ' a -> ' a ) = fun ( x : ' a ) -> f ( f x );; let inc ( x : int ) : int = x + 1 ;; let add2 = twice inc ;; let inc_str ( x : string ) : string = x ^ " " ^ x ;; let add_str = twice ( inc_str );;

# add2 98 ;; - : int = 100 # add_str "Prueba" ;; - : string = "Prueba Prueba Prueba Prueba"

La función twice utiliza una variable de tipo 'a' para indicar que puede aplicarse a cualquier función f que mapee un tipo 'a' a sí misma, en lugar de solo a funciones int->int . En particular, twice incluso puede aplicarse a sí misma.

# let fourtimes f = ( dos veces dos veces ) f ;; val fourtimes : ( ' a -> ' a ) -> ' a -> ' a = < fun > # let add4 = fourtimes inc ;; val add4 : int -> int = < fun > # add4 98 ;; - : int = 102

MetaOCaml ^{[ 24 ]} es una extensión de programación multietapa de OCaml que permite la compilación incremental de nuevo código máquina durante el tiempo de ejecución. En ciertas circunstancias, es posible obtener mejoras de velocidad significativas utilizando la programación multietapa , ya que se dispone de información más detallada sobre los datos a procesar en tiempo de ejecución que en tiempo de compilación regular, por lo que el compilador incremental puede optimizar muchos casos de comprobación de condiciones, etc.

Como ejemplo: si en tiempo de compilación se sabe que se necesita con frecuencia alguna función de potencia , pero el valor de se conoce solo en tiempo de ejecución , se puede utilizar una función de potencia de dos etapas en MetaOCaml:x->x^nn

sea ​​rec potencia n x = si n = 0 entonces .< 1 >. sino si n par entonces sqr ( potencia ( n / 2 ) x ) sino .<.~ x *. .~( potencia ( n - 1 ) x )>.

En cuanto nse conoce en tiempo de ejecución, se puede crear una función de potencia especializada y muy rápida:

.< fun x -> .~( potencia 5 .< x >.)>.

El resultado es:

fun x_1 -> ( x_1 * let y_3 = let y_2 = ( x_1 * 1 ) in ( y_2 * y_2 ) in ( y_3 * y_3 ))

La nueva función se compila automáticamente.

• F# es un lenguaje de framework .NET basado en OCaml.
• JoCaml integra construcciones para el desarrollo de programas concurrentes y distribuidos .
• Reason es una sintaxis y un conjunto de herramientas alternativos para OCaml, creados en Facebook , que pueden compilarse tanto a código nativo como a JavaScript .