OCaml

OCaml (oh-KAM-əl, anteriormente Objective Caml) es un lenguaje de programación multiparadigma de propósito general que amplía el dialecto Caml de ML con object- características orientadas. OCaml fue creado en 1996 por Xavier Leroy, Jérôme Vouillon, Damien Doligez, Didier Rémy, Ascánder Suárez, entre otros.

La cadena de herramientas de OCaml incluye un intérprete interactivo de nivel superior, un compilador de código de bytes, un compilador de código nativo de optimización, un depurador reversible y un administrador de paquetes (OPAM). OCaml se desarrolló inicialmente en el contexto de la demostración automatizada de teoremas y tiene una presencia enorme en el software de análisis estático y métodos formales. Más allá de estas áreas, ha encontrado un uso serio en la programación de sistemas, el desarrollo web y la ingeniería financiera, entre otros dominios de aplicación.

El acrónimo CAML significaba originalmente Lenguaje de máquina abstracto categórico, pero OCaml omite esta máquina abstracta. OCaml es un proyecto de software gratuito y de código abierto administrado y mantenido principalmente por el Instituto Francés de Investigación en Informática y Automatización (Inria). A principios de la década de 2000, muchos lenguajes adoptaron elementos de OCaml, en particular F# y Scala.

Filosofía

Los lenguajes derivados de ML son más conocidos por sus sistemas de tipos estáticos y compiladores de inferencia de tipos. OCaml unifica la programación funcional, imperativa y orientada a objetos bajo un sistema de tipo similar a ML. Por lo tanto, los programadores no necesitan estar muy familiarizados con el paradigma del lenguaje funcional puro para usar OCaml.

Al requerir que el programador trabaje dentro de las restricciones de su sistema de tipo estático, OCaml elimina muchos de los problemas de tiempo de ejecución relacionados con el tipo asociados con los lenguajes de tipo dinámico. Además, el compilador de inferencia de tipo de OCaml reduce en gran medida la necesidad de las anotaciones de tipo manual que se requieren en la mayoría de los lenguajes de tipo estático. Por ejemplo, los tipos de datos de las variables y las firmas de las funciones generalmente no necesitan declararse explícitamente, como ocurre en lenguajes como Java y C#, porque pueden deducirse de los operadores y otras funciones que se aplican a las variables y otros valores. en el código. El uso efectivo del sistema de tipos de OCaml puede requerir cierta sofisticación por parte de un programador, pero esta disciplina se recompensa con un software confiable y de alto rendimiento.

OCaml quizás se distinga más de otros lenguajes con orígenes académicos por su énfasis en el rendimiento. Su sistema de tipo estático evita las discrepancias de tipo en tiempo de ejecución y, por lo tanto, evita las comprobaciones de seguridad y de tipo en tiempo de ejecución que sobrecargan el rendimiento de los lenguajes tipificados dinámicamente, al mismo tiempo que garantiza la seguridad en tiempo de ejecución, excepto cuando la comprobación de límites de matriz está desactivada o cuando se utilizan algunas funciones que no son seguras para tipos, como la serialización.. Estos son lo suficientemente raros como para evitarlos en la práctica.

Además de la sobrecarga de verificación de tipos, los lenguajes de programación funcionales son, en general, difíciles de compilar en un código de lenguaje de máquina eficiente, debido a problemas como el problema funarg. Junto con las optimizaciones estándar de bucles, registros e instrucciones, el compilador de optimización de OCaml emplea métodos de análisis de programas estáticos para optimizar la distribución de valores y la asignación de cierres, lo que ayuda a maximizar el rendimiento del código resultante incluso si hace un uso extensivo de construcciones de programación funcional..

Xavier Leroy ha declarado que "OCaml ofrece al menos el 50 % del rendimiento de un compilador C decente", aunque es imposible realizar una comparación directa. Algunas funciones de la biblioteca estándar de OCaml se implementan con algoritmos más rápidos que las funciones equivalentes en las bibliotecas estándar de otros idiomas. Por ejemplo, la implementación de la unión de conjuntos en la biblioteca estándar de OCaml en teoría es asintóticamente más rápida que la función equivalente en las bibliotecas estándar de lenguajes imperativos (por ejemplo, C++, Java) porque la implementación de OCaml explota la inmutabilidad de los conjuntos para reutilizar partes de la entrada. conjuntos en la salida (ver estructura de datos persistente).

Historia

Desarrollo de ML (Metalenguaje)

Entre las décadas de 1970 y 1980, Robin Milner, científico informático británico y ganador del Premio Turing, trabajó en el Laboratorio de Fundamentos de Ciencias Informáticas de la Universidad de Edimburgo. Milner y otros estaban trabajando en demostradores de teoremas, que se desarrollaron históricamente en lenguajes como Lisp. Milner se encontró repetidamente con el problema de que los probadores de teoremas intentarían afirmar que una prueba era válida juntando pruebas que no son pruebas. 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órficos. 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 propio. ML eventualmente serviría como base para la creación de OCaml.

A principios de la década de 1980, hubo algunos desarrollos que impulsaron al equipo de Formel de INRIA a interesarse en el lenguaje ML. Luca Cardelli, profesor de investigación en la Universidad de Oxford, usó su Functional Abstract Machine 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 varias implementaciones. Simultáneamente, Pierre-Louis Curien, investigador sénior de la Universidad Paris Diderot, desarrolló un cálculo de combinadores categóricos y lo vinculó al cálculo lambda, lo que condujo a la definición de la Máquina Abstracta Categórica (CAM). Guy Cousineau, investigador de la Universidad Paris Diderot, reconoció que esto podría aplicarse como una técnica de compilación para ML.

Primera implementación

Caml fue inicialmente diseñado y desarrollado por el equipo Formel de INRIA encabezado por Gérard Huet. La primera implementación de Caml se creó en 1987 y se desarrolló aún más hasta 1992. Aunque fue encabezado por Ascánder Suárez, Pierre Weis y Michel Mauny continuaron con el desarrollo después de que él se fue en 1988.

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

Camel Light

Entre 1990 y 1991, Xavier Leroy diseñó una nueva implementación de Caml basada en un intérprete de código de bytes escrito en C. Además de esto, Damien Doligez escribió un sistema de administración de memoria, también conocido como recolector de basura secuencial, para esta implementación. Esta nueva implementación, conocida como Caml Light, reemplazó la antigua implementación de Caml y se ejecutó en pequeñas máquinas de escritorio. 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.

Luz especial Caml

En 1995, Xavier Leroy lanzó Caml Special Light, que era una versión mejorada de Caml. Se agregó un compilador optimizador de código nativo al compilador de código de bytes, lo que aumentó considerablemente el rendimiento a niveles comparables con lenguajes convencionales como C++. Además, Leroy diseñó un sistema de módulos de alto nivel inspirado en el sistema de módulos de Standard ML que proporcionó poderosas funciones para la abstracción y la parametrización y facilitó la construcción de programas a mayor escala.

Cámara de objetivos

Didier Rémy y Jérôme Vouillon diseñaron un sistema tipográfico expresivo para objetos y clases, que se integró en Caml Special Light. Esto condujo al surgimiento del lenguaje Objective Caml, lanzado por primera vez en 1996 y posteriormente renombrado como OCaml en 2011. Este sistema de objetos admitió notablemente muchos modismos predominantes orientados a objetos de una manera estáticamente segura, mientras que esos mismos modismos causaron falta de solidez o requirieron Comprobaciones en tiempo de ejecución en lenguajes como C++ o Java. En 2000, Jacques Garrigue amplió Objective Caml con múltiples funciones nuevas, como métodos polimórficos, variantes y argumentos etiquetados y opcionales.

Desarrollo continuo

Las mejoras de lenguaje se han agregado gradualmente durante las últimas dos décadas para admitir las crecientes bases de código comerciales y académicas en OCaml. El lanzamiento de OCaml 4.0 en 2012 agregó tipos de datos algebraicos generalizados (GADT) y módulos de primera clase para aumentar la flexibilidad del lenguaje. El lanzamiento de OCaml 5.0.0 en 2022 es una reescritura completa del tiempo de ejecución del lenguaje, elimina el bloqueo global de GC y agrega controladores de efectos a través de continuaciones delimitadas. Estos cambios permiten la compatibilidad con el paralelismo de memoria compartida y la concurrencia daltónica, respectivamente.

El desarrollo de OCaml continuó dentro del equipo de Cristal en INRIA hasta 2005, cuando fue reemplazado por el equipo de Gallium. Posteriormente, Gallium fue reemplazada por el equipo de Cambium en 2019.

Características

OCaml presenta un sistema de tipos estáticos, inferencia de tipos, polimorfismo paramétrico, recursividad de cola, coincidencia de patrones, cierres léxicos de primera clase, funtores (módulos paramétricos), manejo de excepciones, manejo de efectos y recolección de basura automática generacional incremental.

OCaml se destaca por extender la inferencia de tipo de estilo ML a un sistema de objetos en un lenguaje de propósito general. Esto permite la creación de subtipos estructurales, donde los tipos de objetos son compatibles si las firmas de sus métodos son compatibles, independientemente de su herencia declarada (una característica inusual en los lenguajes tipificados estáticamente).

Se proporciona una interfaz de función externa para vincular a las primitivas de C, incluido el soporte de lenguaje para matrices numéricas eficientes en formatos compatibles con C y Fortran. OCaml también admite la creación de bibliotecas de funciones de OCaml que se pueden vincular a un programa principal en C, de modo que una biblioteca de OCaml se pueda distribuir a los programadores de C que no tienen conocimiento ni instalación de OCaml.

La distribución OCaml contiene:

• Herramientas de análisis y análisis léxicos llamadas ocamllex y ocamlyacc
• Debugger que soporta retroceder para investigar errores
• Generador de documentación
• Perfilador - para medir el rendimiento
• Muchas bibliotecas para fines generales

El compilador de código nativo está disponible para muchas plataformas, incluidas Unix, Microsoft Windows y Apple macOS. La portabilidad se logra a través del soporte de generación de código nativo para las principales arquitecturas: IA-32, X86-64 (AMD64), Power, RISC-V, ARM y ARM64.

Los programas de código de bytes y código nativo de OCaml se pueden escribir en un estilo multiproceso, con cambio de contexto preventivo. Los subprocesos de OCaml en el mismo dominio se ejecutan solo mediante tiempo compartido. Sin embargo, un programa OCaml puede contener varios dominios. Hay varias bibliotecas para computación distribuida como Functory y ocamlnet/Plasma.

Entorno de desarrollo

Desde 2011, se han contribuido muchas herramientas y bibliotecas nuevas al entorno de desarrollo de OCaml:

• Instrumentos de desarrollo
  • opam es un gestor de paquetes para OCaml.
  • Merlin proporciona funcionalidad similar a IDE para múltiples editores, incluyendo retroceso de tipo, ir a la definición y autocomplesión.
  • Dune es un sistema de construcción composable para OCaml.
  • OCamlformat es un auto-formatter para OCaml.
  • ocaml-lsp-servidor es un protocolo de servidor de idiomas para la integración de OCaml IDE.
• Sitios web:
  • OCaml.org es el sitio principal para el idioma.
  • debate.ocaml.org es una instancia de Discurso que sirve como el sitio de discusión principal para OCaml.
• Compiladores alternativos para OCaml:
  • js_of_ocaml, desarrollado por el equipo Ocsigen, es un compilador optimizador de OCaml a JavaScript.
  • BuckleScript, que también apunta a JavaScript, con un enfoque en la producción de salida de JavaScript legible y idiomático.
  • ocamlcc es un compilador de OCaml a C, para complementar el compilador de código nativo para plataformas sin soporte.
  • OCamlJava, desarrollado por INRIA, es un compilador de OCaml a la máquina virtual Java (JVM).
  • OCaPic, desarrollado por Lip6, es un compilador OCaml para microcontroladores PIC.

Ejemplos de código

Los fragmentos de código OCaml se estudian más fácilmente introduciéndolos en el REPL de nivel superior. Esta es una sesión OCaml interactiva que imprime los tipos inferidos de expresiones resultantes o definidas. El nivel superior de OCaml se inicia simplemente ejecutando el programa OCaml:

$ ocaml
 Objetivo Caml versión 3.09.0#

El código se puede ingresar en el "#" oportuno. Por ejemplo, para calcular 1+2*3:

# 1 + 2 * 3;- int = 7

OCaml infiere que el tipo de expresión es "int" (un entero con precisión de máquina) y da el resultado "7".

Hola Mundo

El siguiente programa "hello.ml":

print_endline "¡Hola Mundo!"

se puede compilar en un ejecutable de código de bytes:

Ocamlc hola.ml -o hola

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

Hola. ml -o hola

y ejecutado:

$ ./hello
¡Hola Mundo!$

El primer argumento de ocamlc, "hello.ml", especifica el archivo fuente a compilar y el "-o hello" bandera especifica el archivo de salida.

Opción

El constructor de tipo de opción en OCaml, similar a la mónada Maybe en Haskell, aumenta un tipo de datos dado para devolver algún valor del tipo de datos dado o para devolver ninguno. Esto se usa para expresar que un valor puede o no estar presente.

# Algunos 42;- : int Opción = Algunos 42# Ninguno;- : 'a Opción = Ninguno

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

Deja extracto o = partido o con Silencio Algunos i - string_of_int i Silencio Ninguno - ";

# extracto ()Algunos 42);- : cuerda = "42"# extracto Ninguno;- : cuerda = "

Sumar una lista de enteros

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

Deja rec suma enteros = (* Keyword rec means 'recursive'. *) partido enteros con Silencio [] - 0 (* Rendimiento 0 si los enteros son los vacíos  lista []. *) Silencio primero :: Descansa - primero + suma Descansa; (* Llamada recuperada si los enteros son un no- lista vacía; primero es la primera  elemento de la lista, y el resto es un  lista del 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.

Deja suma enteros = Lista.plegado_izquierda ()diversión accumulator x - accumulator + x) 0 enteros;

 # 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 acortar a:

Deja suma enteros = Lista.plegado_izquierda (+) 0 enteros

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

Deja suma = Lista.plegado_izquierda (+) 0

Ordenación rápida

OCaml se presta a la expresión concisa de algoritmos recursivos. El siguiente ejemplo de código implementa un algoritmo similar a quicksort que ordena una lista en orden creciente.

 Deja rec qsort = función Silencio [] - [] Silencio pivote :: Descansa - Deja is_less x = x . pivote dentro Deja izquierda, derecho = Lista.partición is_less Descansa dentro qsort izquierda @ [pivote] @ qsort derecho

O usando la aplicación parcial del operador >=.

 Deja rec qsort = función Silencio [] - [] Silencio pivote :: Descansa - Deja is_less = (=) pivote dentro Deja izquierda, derecho = Lista.partición is_less Descansa dentro qsort izquierda @ [pivote] @ qsort derecho

Problema de cumpleaños

El siguiente programa calcula el número más pequeño de personas en una habitación para quienes la probabilidad de cumpleaños completamente únicos es inferior 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).

Deja year_size = 365.Deja rec birthday_paradox Prob gente = Deja Prob = ()year_size -. flotador gente) /. year_size *. Prob dentro si Prob . 0.5 entonces Printf.printf "Respuesta = %dn" ()gente+1) más birthday_paradox Prob ()gente+1);birthday_paradox 1.0 1

Números de la iglesia

El siguiente código define una codificación Church de números naturales, con sucesor (succ) y adición (add). Un número de iglesia n es un número superior función de orden que acepta una función f y un valor x y aplica f a x exactamente n veces. Para convertir un número de iglesia de un valor funcional a una cadena, le pasamos una función que antepone la cadena < span class="s2">"S" a su entrada y la cadena constante "0".

Deja cero f x = xDeja succ n f x = f ()n f x)Deja uno = succ ceroDeja dos. = succ ()succ cero)Deja añadir n1 n2 f x = n1 f ()n2 f x)Deja to_string n = n ()diversión k - "S" ^ k) "0"Deja ¿Qué? = to_string ()añadir ()succ dos.) dos.)

Función factorial de precisión arbitraria (bibliotecas)

Se puede acceder directamente a una variedad de bibliotecas desde OCaml. Por ejemplo, OCaml tiene una biblioteca integrada para aritmética de precisión arbitraria. Como la función factorial crece muy rápidamente, rápidamente desborda los números de precisión de máquina (típicamente 32 o 64 bits). Por lo tanto, factorial es un candidato adecuado 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:

# #uso "topfind";# #necesidad "num";# abierto Número;

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

# Deja rec hecho n = si n =/ Int 0 entonces Int 1 más n */ hecho()n -/ Int 1);val hecho : Número.num - Número.num = .diversión■

¡Esta función puede calcular factoriales mucho más grandes, como 120!:

# string_of_num ()hecho ()Int 120));- : cuerda ="6689502913449127057588118054090372586752746333138029810295671352301633557244962989366874165271984981308157637893214090552534408589408121859898481114389650005964960521256960000000000000000000000000"

Triángulo (gráficos)

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

Deja () = ignorar ()Glut.init Sys.argv); Glut.initDisplayMode ~double_buffer:verdadero (); ignorar ()Glut.crearWindow ~Título:"Democión OpenGL"); Deja ángulo t = 10. *. t *. t dentro Deja render () = GlClear.clara [ `color ]; GlMat.load_identity (); GlMat.rotación ~ángulo: ()ángulo ()Sys.tiempo ()) ~z:1. (); GlDraw.Comienza `triángulos; Lista.iter GlDraw.vertex2 [...1., -1.; 0., 1.; 1., -1.]; GlDraw.fines (); Glut.swapBuffers () dentro GlMat.modo `modelo; Glut.displayFunc ~cb:render; Glut.idleFunc ~cb:Algunos Glut.postRedisplay); Glut.mainLoop ()

Se requieren los enlaces de LablGL a OpenGL. Luego, el programa se puede compilar en 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 simplemente, usando el comando de compilación ocamlfind

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

y ejecuta:

$/simple

Se pueden desarrollar programas gráficos 2D y 3D mucho más sofisticados y de alto rendimiento en OCaml. Gracias al uso de OpenGL y OCaml, los programas resultantes pueden ser multiplataforma, compilando sin cambios en muchas de las principales plataformas.

Secuencia de Fibonacci

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

Deja fib n = Deja rec fib_aux m a b = partido m con Silencio 0 - a Silencio ¿Qué? - fib_aux ()m - 1) b ()a + b) dentro fib_aux n 0 1

Funciones de orden superior

Las funciones pueden tomar funciones como entrada y devolver 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.

Deja Dos veces. ()f : 'a - 'a) = diversión ()x : 'a) - f ()f x);Deja inc ()x : int) : int = x + 1;Deja add2 = Dos veces. inc;Deja inc_str ()x : cuerda) : cuerda = x ^ " ^ x;Deja add_str = Dos veces.()inc_str);

 # add2 98; - : int = 100 # add_str "Test"; - : cuerda = "Test Test Test"

La función dos veces usa una variable de tipo 'a para indicar que se puede aplicar a cualquier función f mapeando desde un escriba 'a para sí mismo, en lugar de solo para las funciones int->int. En particular, dos veces puede incluso aplicarse a sí mismo.

 # Deja cuatro veces f = ()Dos veces. Dos veces.) f; val cuatro veces : ()'a - 'a) - 'a - 'a = .diversión■ # Deja add4 = cuatro veces inc; val add4 : int - int = .diversión■ # add4 98; - : int = 102

Idiomas derivados

MetaOCaml

MetaOCaml es una extensión de programación de varias etapas de OCaml que permite la compilación incremental de código de máquina nuevo durante el tiempo de ejecución. En algunas circunstancias, se pueden lograr aceleraciones significativas mediante la programación de varias etapas, ya que se dispone de información más detallada sobre los datos que se van a procesar en el tiempo de ejecución que en el tiempo de compilación normal, por lo que el compilador incremental puede optimizar muchos casos de verificación de condiciones, etc.

Como ejemplo: si en tiempo de compilación se sabe que alguna función de potencia x -> x^< span class="n">n se necesita a menudo, pero el valor de n solo se conoce en tiempo de ejecución, se puede usar una función de potencia de dos etapas en MetaOCaml:

Deja rec poder n x = si n = 0 entonces ..1. más si incluso n entonces sqr ()poder ()n/2) x) más .x *. .~poder ()n - 1) x).

Tan pronto como n se conoce en tiempo de ejecución, se puede crear una función de potencia especializada y muy rápida:

..diversión x - .~poder 5 ..x- No.

El resultado es:

diversión x_1 - ()x_1 * Deja Y_3 = Deja Y_2 = ()x_1 * 1) dentro ()Y_2 * Y_2) dentro ()Y_3 * Y_3)

La nueva función se compila automáticamente.

Otros lenguajes derivados

• AtomCaml proporciona una sincronización primitiva para la ejecución atómica (transaccional) del código.
• Emily (2006) es un subconjunto de OCaml 3.08 que utiliza un verificador de reglas de diseño para hacer cumplir los principios de seguridad modelo de viabilidad de objetos.
• F# es un.NET Framework language basado en OCaml.
• Fresh OCaml facilita la manipulación de nombres y carpetas.
• GCaml añade polimorfismo extensivo a OCaml, permitiendo así sobrecargas y mariscalización de tipo seguro.
• JoCaml integra construcciones para desarrollar programas concurrentes y distribuidos.
• OCamlDuce extiende OCaml con características como expresiones XML y tipos de expresión regulares.
• OCamlP3l es un sistema de programación paralelo basado en OCaml y P3L.
• Razón es una sintaxis alternativa de OCaml y una cadena de herramientas para OCaml creada en Facebook, que puede compilar tanto en código nativo como en JavaScript.
• ReScript es un nuevo lenguaje de la cadena de herramientas Reason/BuckleScript, que tiene una sintaxis diferente y sólo compila a JavaScript.

Software escrito en OCaml

• 0install, un gestor de paquetes multiplataforma.
• CamlPDF, una biblioteca OCaml para leer, escribir y modificar archivos PDF
• Coccinelle, una utilidad para transformar el código fuente de los programas C.
• Coq, un sistema formal de gestión de pruebas.
• FFTW, una biblioteca para computar transformaciones discretas Fourier. Varios Las rutinas C han sido generadas por un programa OCaml llamado genfft.
• La versión web de Facebook Messenger.
• Flujo, un analizador estático creado en Facebook que infiere y comprueba tipos estáticos para JavaScript.
• Owl Scientific Computing, un sistema dedicado para la informática científica y de ingeniería.
• Frama-C, un marco para analizar los programas C.
• GeneWeb, software de genealogía multiplataforma libre y de código abierto.
• El compilador de lenguaje de programación Hack, creado en Facebook, extendiendo PHP con tipos estáticos.
• El compilador de lenguaje de programación Haxe.
• HOL Light, asistente de pruebas formales.
• Infer, un analizador estático creado en Facebook para Java, C, C++ y Objective-C, utilizado para detectar errores en aplicaciones iOS y Android.
• Lexifi Apropos, un sistema para modelar derivados complejos.
• MirageOS, un marco de programación unikernel escrito en OCaml puro.
• MLdonkey, una aplicación para compartir archivos entre pares basada en la red EDonkey.
• Ocsigen, un marco web OCaml.
• Opa, un lenguaje de programación libre y de código abierto para el desarrollo web.
• pyre-check, un tipo de comprobación para Python creado en Facebook.
• Semgrep, una herramienta de búsqueda de errores que soporta muchos idiomas de programación.
• Tezos, una plataforma de contrato inteligente auto-recomendante usando XTZ como moneda nativa.
• Unison, un programa de sincronización de archivos para sincronizar archivos entre dos directorios.
• El intérprete de referencia para WebAssembly, un bytecode de bajo nivel destinado a la ejecución dentro de los navegadores web.
• Xen Cloud Platform (XCP), una solución de virtualización llave en mano para el hipervisor Xen.

Usuarios

Varias docenas de empresas utilizan OCaml hasta cierto punto. Los ejemplos notables incluyen:

• Bloomberg L.P., que creó BuckleScript, un backend compilador OCaml que apunta a JavaScript.
• Citrix Systems, que utiliza OCaml en XenServer (remarcado como Citrix Hypervisor durante 2018).
• Facebook, que desarrolló Flow, Hack, Infer, Pfff y Razón en OCaml.
• Jane Street Capital, una firma de comercio propietario, que adoptó OCaml como su idioma preferido en sus primeros días.