Mercury es un lenguaje de programación lógico-funcional diseñado para aplicaciones de alta confiabilidad. Combina la expresividad de Prolog con un sistema de tipos estático, análisis de modos e inferencia de determinismo.
Desarrollado en la Universidad de Melbourne (Australia) por Zoltan Somogyi, Thomas Conway y Fergus Henderson a mediados de los años 90.
A diferencia de Prolog, Mercury está compilado y produce código de máquina eficiente.
Su paradigma es lógico, funcional y declarativo.
¿Para qué sirve?
Es ideal para:
- Para programas que requieren razonamiento lógico complejo, como sistemas expertos, análisis simbólico, verificación formal y compiladores.
- En investigación académica y en proyectos donde la corrección y optimización son críticas.
Su compilador genera código eficiente en C o directamente en LLVM, permitiendo alto rendimiento.
Relación con Prolog
- Mercury hereda la semántica lógica de Prolog (basada en resolución y unificación).
- Usa predicados y cláusulas como Prolog, pero con tipado estático, determinismo explícito y análisis de modos.
- Se puede considerar una evolución de Prolog, orientada a la seguridad y optimización.
Comparativa entre Mercury y Prolog
| Aspecto | Prolog | Mercury |
|---|---|---|
| Paradigma | Lógico puro | Lógico‑funcional con tipado estático |
| Tipado | Dinámico | Estático y fuerte |
| Determinismo | Implícito | Explícito (debe declararse) |
| Eficiencia | Interpretado o compilado con menor optimización | Compilado a C/LLVM con optimizaciones avanzadas |
| Errores en tiempo de ejecución | Más frecuentes por falta de tipos | Detectados en compilación |
| Sintaxis | Más simple y flexible | Más estricta y formal |
| Inferencia de tipos | No disponible | Automática y segura |
| Uso principal | Prototipado rápido, IA simbólica | Aplicaciones lógicas grandes y seguras |
| Origen | Década de 1970 (Colmerauer, Kowalski) | Década de 1990 (Somogyi, Conway, Henderson) |
Instalando Mercury
Para descargarlo debemos ir a este sitio: https://www.mercurylang.org/download.html
En caso de no querer instalarlo, puedes probarlo desde este sitio: https://glot.io/new/mercury
¿Qué puedes programar en Mercury?
Los tipos de programas que puedes desarrollar en Mercury se caracterizan por necesitar razonamiento lógico complejo, seguridad en el tipado y eficiencia en ejecución. Veamos algunas cosas que se podrían hacer con este lenguaje:
- Sistemas expertos y de inferencia lógica. Ejemplo: motores de reglas para diagnóstico médico, asesoría legal o análisis financiero.
- Compiladores y herramientas de análisis de código. Gracias a su tipado fuerte y análisis de modos, Mercury es ideal para escribir parsers, analizadores semánticos y transformadores de código.
- Verificación formal y model checking. Programas que requieren demostrar propiedades matemáticas de sistemas, como verificar que un protocolo de comunicación cumple ciertas reglas.
- Aplicaciones de inteligencia artificial simbólica Similar a Prolog, puedes construir sistemas de razonamiento, planificación y resolución de problemas basados en lógica.
- Procesamiento de datos estructurados. Mercury puede manejar transformaciones complejas de datos (XML, JSON, etc.) con seguridad y eficiencia.
- Investigación académica y proyectos experimentales. Lenguaje usado en papers y prototipos donde se busca combinar declaratividad con rendimiento.
Programando en Mercury
Miremos algunos ejemplos.
Ejemplo 1. El clásico "Hola, mundo" en Prolog y Mercury.
En Prolog:
holamundo.pl
% holamundo.pl main :- write('Hola, mundo'), nl.
En Mercury:
holamundo.m
% holamundo.m :- module holamundo. :- interface. :- import_module io. :- pred main(io::di, io::uo) is det. :- implementation. main(!IO) :- io.write_string("Hola, mundo\n", !IO).
Compilación y ejecución:
$ mmc holamundo.m $ ./holamundo.exe
Salida:
Hola, mundo
Ejemplo 2. Ejemplo de relaciones. En este caso entre objetos, padre-hijo.
En Prolog:
familia.pl
% familia.pl padre(juan, maria). padre(juan, pedro). % Regla: abuelo abuelo(X, Y) :- padre(X, Z), padre(Z, Y). % Consulta: % $ swipl % ?- [familia]. % ?- abuelo(juan, _).
En Mercury:
familia.m
% familia.m :- module familia. :- interface. :- import_module io, list, solutions. :- pred main(io::di, io::uo) is det. :- implementation. :- type persona ---> juan ; maria ; pedro ; ana. % Relación padre :- pred padre(persona::in, persona::out) is nondet. padre(juan, maria). padre(juan, pedro). padre(pedro, ana). % Relación abuelo :- pred abuelo(persona::in, persona::out) is nondet. abuelo(X, Y) :- padre(X, Z), padre(Z, Y). main(!IO) :- % Recolectamos todas las soluciones de abuelo(juan, Nieto) Solutions = solutions(abuelo(juan)), ( Solutions = [], io.write_string("Juan no es abuelo\n", !IO) ; Solutions = [N | Ns], io.write_string("Juan es abuelo de: ", !IO), io.write_list([N | Ns], ", ", io.write, !IO), io.nl(!IO) ).
Compilación y ejecución:
$ mmc familia.m $ ./familia.exe
Salida:
Juan es abuelo de: ana
Ejemplo 3. Saber si un número es par.
En Prolog:
numeros.pl
% numeros.pl par(X) :- 0 is X mod 2. % $ swipl % ?- [numeros]. % ?- par(4).
En Mercury:
numeros.m
% numeros.m :- module numeros. :- interface. :- import_module io, int. :- pred main(io::di, io::uo) is det. :- implementation. :- pred par(int::in) is semidet. par(N) :- N mod 2 = 0. main(!IO) :- ( if par(4) then io.write_string("4 es par\n", !IO) else io.write_string("4 no es par\n", !IO) ).
Compilación y ejecución:
$ mmc numeros.m $ ./numeros.exe
Salida:
4 es par
¡Hemos creado nuestros primeros programas en Mercury!
Continuaremos en próximas entregas.
Enlaces:
https://blog.adrianistan.eu/mercury-prolog-haskell-bebe/https://guedemann.org/articles/mercury-intro-curry-club.html
https://en.wikipedia.org/wiki/Mercury_(programming_language)
https://www.mercurylang.org/
https://ferestrepoca.github.io/paradigmas-de-programacion/proglogica/tutoriales/mercury_2026-1/index.html
Comentarios
Publicar un comentario