Mercury: cuando Prolog y Haskell tuvieron un bebé

main(IO, IO1) :-
    write_string("¡Hola Mercury!\n", IO, IO1)

Y ahí ya se ve claramente como los argumentos coinciden con lo que declaramos en la interfaz. Estas variables de estado se pueden encadenar y el azúcar sintáctico también nos ayuda a hacer refactorizaciones más sencillas en código con variables de estado encadenadas.

Para compilar, ejecutamos mmc

mmc hola.m

Y ya tenemos un ejecutable nativo llamado "hola" que podemos ejecutar.

Funciones

Aparte de predicados, Mercury también tiene funciones, algo de lo que carece Prolog. Veamos este ejemplo para calcular la sucesión de fibonacci:

:- module fib.
:- interface.

:- import_module io.

:- pred main(io::di, io::uo) is det.

:- implementation.

:- import_module int.

:- func fibonacci(int) = int.

fibonacci(N) =
    ( if (N = 0;N = 1) then
        1
    else
        fibonacci(N-1) + fibonacci(N-2)
    ).

main(!IO) :-
    F = fibonacci(5),
    io.write_int(F, !IO),
    io.nl(!IO).

En este ejemplo, declaramos dentro de la implementación la función fibonacci, que toma un int y devuelve un int. Para usar int tenemos que importar el módulo, como solo lo necesitamos en la implementación, no lo importamos en la interfaz. Después la función se define con otra sintaxis. Aquí podemos ver los if-then-else (aunque la sintaxis de Prolog ( -> ; ) también es admitida). Más diferencias que podemos ver respecto a Prolog es que las expresiones aritméticas se evalúan directamente.

Por último, en main, llamamos a la función fibonacci e imprimimos el resultado. Aquí usamos el nombre cualificado de los predicados, con io delante. Es opcional en muchos casos pero altamente recomendable ponerlo.

Tipos de datos

Vamos a entrar más en detalle en los tipos de datos de Mercury, que toman una fuerte inspiración de Haskell.

Lo primero que hay que tener en cuenta es que en Mercury, todos las variables van a ser inmutables. Sin embargo, a diferencia de Prolog, el compilador puede inferir lugares donde aplicar mutabilidad internamente para mejorar el rendimiento.

Los tipos más básicos son int, float, string y char. Además contamos con tuplas y listas.

Las tuplas son un número de elementos prefijados de tipo diferente, por ejemplo, {5, "hola"} es una tupla de tipo {int, string}

Las listas en Mercury son colecciones de N elementos, todos ellos del mismo tipo.[3,4,5,6] es de tipo list(int). Las listas se pueden deconstruir como en Prolog usando la barra vertical. Si L = [1,2,3,4] y L = [X|Xs], entonces X es igual a 1 y Xs a [2,3,4].

Tipos suma

Mercury soporta tipos suma. Los más básicos son simples enumeraciones.

:- type color ---> red ; green ; yellow ; blue ; black ; white ; purple.

En este caso crearíamos el tipo color con esos posibles valores. Pero cada enumeración puede llevar asociado algún dato extra.

:- type font ---> serif(color) ; sans_serif ; mono.

En este caso los tipos de fuente pueden ser Serif, Sans-Serif y Mono, pero en el caso de la Serif, lleva asociado un color.

Estos campos extra pueden tener un nombre, para acceder a ellos más fácilmente mediante ^. De este modo tendríamos lo que en otros lenguajes se llama records o estructuras.

:- type mail ---> mail( from :: string, to :: string, msg :: string).

% mas adelante
...
ToAddress = Mail^to,
...

Con := podemos crear un nuevo record igual al anterior pero cambiando el valor de un campo.

:- type mail ---> mail( from :: string, to :: string, msg :: string).

...
    Mail = mail("a@example.org", "b@example.org", "Test message"),
    Mail1 = (Mail^to := "c@example.org"),
    (if Mail1^to = "b@example.org" then
        io.write_string("Mail to B\n", !IO)
    else
        io.write_string("Mail NOT to B\n", !IO)
    ),
...

En este caso se ejecutaría la parte de "Mail NOT to B".

Tipos polimórficos

Mercury soporta polimorfismo a nivel de tipo. Es posible crear estructuras de datos genéricas para un tipo de dato T. El ejemplo más archiconocido es la lista, que en Mercury podríamos definirla así.

:- type list(T) ---> [] ; [T | list(T)].

Tipos equivalentes

En Mercury podemos crear tipos idénticos a otros, pero con distinto nombre para mejorar la legibilidad.

:- type money == int.
:- type radius == float.

Modos en Mercury

Un elemento vital para Mercury es la declaración de modos de los predicados. En parte ya lo hemos visto, ya que al declarar los predicados estábamos indicando los modos a la vez, pero en realidad puede separarse en dos directivas diferentes. Los modos indican a Mercury la "dirección" del código así como las posibles soluciones.

Partamos de un ejemplo sencillo, un predicado (no función) de suma, donde pasamos los dos sumandos mediante una tupla.

:- pred suma_tuple({int, int}::in, int::out) is det.

suma_tuple({X, Y}, Z) :-
    Z = X + Y.

En la línea de declaración hemos combinado los tipos y los modos. Esto se puede separar. Será obligatorio separar si queremos que un predicado se compile con más de un modo.

:- pred suma_tuple({int, int}, int).
:- mode suma_tuple(in, out) is det.
suma_tuple({X, Y}, Z) :-
    Z = X + Y.

En la declaración de modo indicamos que variables son de entrada y cuáles de salida. Además definimos el número de soluciones. Los posibles valores son: det (=1), semidet (<=1), multi(>= 1), nondet (>=0) y failure (=0).

:- pred phone(string, string).
:- mode phone(in, out) is semidet.
phone("123456789", "Benito").
phone("245678901", "Mar").

En este ejemplo phone va a tener un modo, donde proveemos un número y nos devuelve el nombre. Es semidet ya que puede que no encuentre el teléfono (no hay solución) o que sí. Pero no podemos devolver más de una solución (podríamos si lo declaramos como nondet).

Con este modo podemos hacer estas llamadas:

    (if phone("123456789", _Name) then
        io.write_string("Phone found\n", !IO)
    else
        true
    ),

Sin embargo, no podemos hacer lo inverso.

    (if phone(_Phone, "Benito") then
        io.write_string("Phone found\n", !IO)
    else
        true
    ),

Para que compile deberemos agregar este otro modo:

:- mode phone(out, in) is semidet.

Existen más tipos de modo pero no serán tan habituales.

Ejemplo más grande

He aquí un ejemplo de como se resolvería el problema 1 del Advent of Code de 2021 en Mercury (ambas partes).

:- module aoc2021day1.
:- interface.

:- import_module io.

:- pred main(io::di, io::uo) is det.

:- implementation.

:- import_module int.
:- import_module list.
:- import_module string.

:- pred load_data(string::in, list(string)::out, io::di, io::uo) is det.

load_data(Filename, ReadData, !IO) :-
    io.read_named_file_as_lines(Filename, OpenResult, !IO),
    (if OpenResult = ok(Data) then
        ReadData = Data
     else
        ReadData = []
    ).

:- pred solve(list(int)::in, int::out) is det.
solve([], 0).
solve([_], 0).
solve([X,Y|Xs], N) :-
    solve([Y|Xs], N0),
    (if X < Y then
        N = N0 + 1
    else
        N = N0
    ).

:- pred slide_window(list(int)::in, list(int)::out) is det.
slide_window([], []).
slide_window([_], []).
slide_window([_,_], []).
slide_window([X,Y,Z|Xs], Ys) :-
    slide_window([Y,Z|Xs], Ys0),
    N = X + Y + Z,
    Ys = [N|Ys0].

:- pred solve2(list(int)::in, int::out) is det.
solve2(Data, N) :-
    slide_window(Data, Slides),
    solve(Slides, N).

main(!IO) :-
    load_data("input", ReadData, !IO),
    (if list.map(string.to_int, ReadData, Data) then
        solve(Data, N),
	io.format("Solution 1: %d\n", [i(N)], !IO),
	solve2(Data, M),
	io.format("Solution 2: %d\n", [i(M)], !IO)
    else
        io.write_string("Invalid file\n", !IO)
    ).

Typeclasses

En Mercury podemos crear typeclasses de forma muy similar a Haskell. También son muy parecidas a las traits de Rust. Con typeclasses podemos restringir los argumentos de un predicado/función a tipos que implementen la typeclass que nos interesa.

:- typeclass shape(T) where [].

:- type point ---> point(float, float).
:- type rectangle ---> rectangle(point, float, float).
:- type circle ---> circle(point, float).

:- instance shape(rectangle) where [].
:- instance shape(circle) where [].

En este ejemplo, creamos una typeclass llamada shape, sin más requisitos y creamos 3 tipos: point, rectangle y circle. De estos, dos van a ser instancias de la typeclass shape: rectangle y circle.

Posteriormente podremos definir predicados donde solo admitamos tipos que implementen shape, pero nos da igual si son rectangle o circle, de la siguiente forma.

:- pred shapes_only(T::in) is det <= shape(T).

Sin embargo, la verdadera utilidad es que las typeclasses impongan ciertos predicados que deben implementarse para poder ser instancia de algo. En nuestro ejemplo de shape, podemos poner calcular el área. Es algo que en todas las figuras puede hacerse, pero el método es diferente si es un rectángulo o si es un círculo.

Para ello, declaramos predicados y modos en la typeclass:

:- typeclass shape(T) where [
    pred get_area(T, float),
    mode get_area(in, out) is det
].

Al instanciar, podemos añadir el código directamente o hacer referencia a un predicado externo.

:- instance shape(rectangle) where [
    (get_area(Rect, Area) :-
        Rect = rectangle(_Centre, Width, Height),
	Area = Width * Height
    )
].
:- instance shape(circle) where [
   pred(get_area/2) is circle_area
].

:- pred circle_area(circle::in, float::out) is det.
circle_area(circle(_Centre, Radius), Area) :-
    Area = math.pi * Radius * Radius.

Un ejemplo completo de uso de typeclasses a continuación:

:- module shape.
:- interface.

:- import_module io.
:- pred main(io::di, io::uo) is det.

:- implementation.

:- import_module float.
:- import_module list.
:- import_module math.
:- import_module string.

:- typeclass shape(T) where [
    pred get_area(T, float),
    mode get_area(in, out) is det
].

:- type point ---> point(float, float).
:- type rectangle ---> rectangle(point, float, float).
:- type circle ---> circle(point, float).

:- instance shape(rectangle) where [
    (get_area(Rect, Area) :-
        Rect = rectangle(_Centre, Width, Height),
	Area = Width * Height
    )
].
:- instance shape(circle) where [
   pred(get_area/2) is circle_area
].

:- pred circle_area(circle::in, float::out) is det.
circle_area(circle(_Centre, Radius), Area) :-
    Area = math.pi * Radius * Radius.

:- pred print_area(T::in, io::di, io::uo) is det <= shape(T).
print_area(Shape, !IO) :-
    get_area(Shape, Area),
    io.format("Area of shape: %f\n", [f(Area)], !IO).

main(!IO) :-
    print_area(rectangle(point(1.0, 2.0), 30.0, 10.0), !IO),
    print_area(circle(point(1.0, 2.0), 10.0), !IO).

Con esto ya conoceríamos las principales mejoras de Mercury respecto a Prolog y damos por acabado el tutorial. ¿Qué te parece Mercury? ¿Prefieres la brevedad de Prolog o la explicitud de Mercury?