Mercurio (lenguaje de programación)

Mercury es un lenguaje de programación de lógica funcional creado para usos en el mundo real. La primera versión fue desarrollada en el departamento de Ciencias de la Computación de la Universidad de Melbourne por Fergus Henderson, Thomas Conway y Zoltan Somogyi, bajo la supervisión de Somogyi, y se lanzó el 8 de abril de 1995.

Mercury es un lenguaje de programación de lógica puramente declarativa. Está relacionado tanto con Prolog como con Haskell. Presenta un sistema de tipo fuerte, estático y polimórfico, y un sistema de modo y determinismo fuerte.

La implementación oficial, Melbourne Mercury Compiler, está disponible para la mayoría de las plataformas Unix y similares, incluidas Linux, macOS y Windows.

Resumen

Mercury se basa en el lenguaje de programación lógica Prolog. Tiene la misma sintaxis y los mismos conceptos básicos, como el algoritmo de resolución de cláusula definida lineal selectiva (SLD). Se puede ver como un subconjunto puro de Prolog con tipos y modos fuertes. Como tal, a menudo se compara con su predecesor en características y eficiencia de tiempo de ejecución.

El lenguaje está diseñado utilizando principios de ingeniería de software. A diferencia de las implementaciones originales de Prolog, tiene una fase de compilación separada, en lugar de interpretarse directamente. Esto permite detectar una gama mucho más amplia de errores antes de ejecutar un programa. Cuenta con un estricto sistema de tipo y modo estático y un sistema de módulos.

Al utilizar la información obtenida en el momento de la compilación (como el tipo y el modo), los programas escritos en Mercury suelen funcionar significativamente más rápido que los programas equivalentes escritos en Prolog. Sus autores afirman que Mercury es el lenguaje lógico más rápido del mundo, por un amplio margen.

Mercury es un lenguaje puramente declarativo, a diferencia de Prolog, ya que carece de declaraciones de Prolog extra-lógicas como ! (cut) y entrada/salida imperativa (E/S).). Esto permite el análisis avanzado de programas estáticos y la optimización de programas, incluida la recolección de basura en tiempo de compilación, pero puede hacer que ciertas construcciones de programación (como cambiar varias opciones, con un valor predeterminado) sean más difíciles de expresar. Si bien Mercury permite una funcionalidad impura, sirve principalmente como una forma de llamar a un código de idioma extranjero. Todo código impuro debe estar marcado explícitamente. Las operaciones que normalmente serían impuras (como entrada/salida) se expresan usando construcciones puras en Mercury usando tipos lineales, enhebrando un valor mundial ficticio a través de todo el código relevante.

Los programas notables escritos en Mercury incluyen el compilador Mercury y el formateador Prince XML. La empresa de software ODASE también ha estado utilizando Mercury para desarrollar su plataforma de desarrollo de software centrado en ontologías, ODASE.

Back-end

Mercury tiene varios back-end, que permiten compilar el código de Mercury en varios idiomas, incluidos:

Nivel de producción

• Low-level C for GNU Compiler Collection (GCC), el original Mercury back-end
• Alto nivel C
• Java
• C#

Pasado

• Lenguaje de la Asamblea a través del back-end del GCC
• Aditi, un sistema de base de datos deductivo también desarrollado en la Universidad de Melbourne. Mercury-0.12.2 es la última versión para apoyar a Aditi.
• Idioma Intermedio Común (CIL) para el. Marco NET
• Erlang

Mercury también cuenta con una interfaz de idioma extranjero, lo que permite que el código en otros idiomas (según el back-end elegido) se vincule con el código de Mercury. Los siguientes idiomas extranjeros son posibles:

Se puede conectar a otros idiomas llamándolos desde estos idiomas. Sin embargo, esto significa que es posible que sea necesario escribir el código de un idioma extranjero varias veces para los diferentes backends; de lo contrario, se perderá la portabilidad entre backends.

El back-end más utilizado es el back-end C original de bajo nivel.

Ejemplos

Hola Mundo:

 :- módulo Hola.. :- interfaz. :- import_module io. :- pred principal()io::di, io::uo) es Det. :- aplicación. principal(!IO) :-io.escritura_string()¡Hola, Mundo!, !IO).

Calcular el décimo número de Fibonacci (de la manera más obvia):

 :- módulo fib. :- interfaz. :- import_module io. :- pred principal()io::di, io::uo) es Det. :- aplicación. :- import_module int. :- func fib()int) = int. fib()N) = ()si N =. 2 entonces 1 más fib()N - 1) + fib()N - 2)). principal(!IO) :- io.escritura_string()"fib(10) = ", !IO), io.escritura_int()fib()10), !IO), io.#(!IO). % En cambio, podría usar io.format("fib(10) = %dn", [i(fib(10)], !IO).

!IO es una "variable de estado", que es azúcar sintáctica para un par de variables a las que se les asignan nombres concretos en la compilación; por ejemplo, lo anterior está desazucarado a algo como:

 principal()IO0, IO) :- io.escritura_string()"fib(10) = ", IO0, IO1), io.escritura_int()fib()10), IO1, IO2), io.#()IO2, IO).

Programa de lanzamiento

El esquema de nomenclatura de las versiones estables fue de 0,1 a 0,13 para las primeras trece versiones estables. En febrero de 2010, el proyecto Mercury decidió nombrar cada lanzamiento estable utilizando el año y el mes del lanzamiento. Por ejemplo, 10.04 es para una versión realizada en abril de 2010.

A menudo también hay una instantánea periódica del sistema de desarrollo lanzamiento del día (ROTD)

Compatibilidad con IDE y editores

• Los desarrolladores proporcionan soporte para Vim
• Biblioteca Flycheck para Emacs
• Un plugin está disponible para el Eclipse IDE
• Un plugin está disponible para el IDE de NetBeans