Editing Mercury (programming language)

{{Short description|Functional logic programming language}}
{{For|Mercury Autocode|Autocode}}
{{Distinguish|Mercurial|Mercury (RemObjects BASIC programming language)}}

{{Infobox programming language
| name = Mercury
| logo = Mercury (programming language) logo.jpg
| logo size = 250px
| paradigm = [[Logic programming|Logic]], [[Functional programming|functional]], [[Object-oriented programming|object-oriented]]{{citation needed|date=February 2024}}
| family = 
| designer = Zoltan Somogyi
| developer = [[University of Melbourne]]
| released = {{Start date and age|1995|04|08}}| latest release version = {{wikidata|property|preferred|references|edit|P348|P548=Q2804309}}                                             | latest release date    = {{Start date and age|{{wikidata|qualifier|preferred|single|P348|P548=Q2804309|P577}}|df=yes}}
| typing = [[Strong and weak typing|Strong]], [[Type system#Static type checking|static]], [[Polymorphism (computer science)|polymorphic]]
| scope = 
| programming language = Mercury
| platform = [[IA-32]], [[x86-64]], [[ARM architecture family|Arm]], [[SPARC]]64, [[Java (software platform)|Java]], [[Common Language Infrastructure|CLI]]
| operating system = [[Cross-platform software|Cross-platform]]: [[Unix]], [[Linux]], [[macOS]], [[Oracle Solaris|Solaris]], [[FreeBSD]], [[OpenBSD]], [[Microsoft Windows|Windows]], [[Android (operating system)|Android]]
| license = [[GNU General Public License|GPL]] compiler,<br/>[[GNU Lesser General Public License|LGPL]] standard library
| file ext = .m
| file format = 
| website = {{url|https://www.mercurylang.org/|mercurylang.org}}
| implementations = Melbourne Mercury Compiler
| dialects = 
| influenced by = [[Prolog]], [[Hope (programming language)|Hope]], [[Haskell]]
| influenced = 
}}

'''Mercury''' is a [[functional logic programming]] language made for real-world uses. The first version was developed at the [[University of Melbourne]], Computer Science department, by Fergus Henderson, Thomas Conway, and Zoltan Somogyi, under Somogyi's supervision, and released on April 8, 1995.

Mercury is a purely [[Declarative programming|declarative]] [[logic programming]] language. It is related to both [[Prolog]] and [[Haskell]].<ref name="motivation">[http://www.mercurylang.org/about/motivation.html The Mercury Project - Motivation]</ref> It features a strong, static, polymorphic [[type system]], and a strong mode and determinism system.

The official implementation, the Melbourne Mercury Compiler, is available for most [[Unix]] and [[Unix-like]] platforms, including [[Linux]], [[macOS]], and for [[Microsoft Windows|Windows]].

==Overview==
Mercury is based on the logic programming language [[Prolog]]. It has the same syntax and the same basic concepts such as the [[SLD resolution|selective linear definite clause resolution]] (SLD) algorithm. It can be viewed as a pure subset of Prolog with strong types and modes. As such, it is often compared to its predecessor in features and run-time efficiency.

The language is designed using [[software engineering]] principles. Unlike the original implementations of Prolog, it has a separate [[compiler|compilation]] phase, rather than being directly interpreted. This allows a much wider range of errors to be detected before running a program. It features a strict [[Type system#Static type checking|static type]] and mode system<ref name=motivation/> and a module system.

By using information obtained at compile time (such as type and mode), programs written in Mercury typically perform significantly faster than equivalent programs written in Prolog.<ref name="benchmarks">[http://www.mercurylang.org/about/benchmarks.html The Mercury Project - Benchmarks]</ref><ref name="jlp">{{cite journal
 |last= Somogyi
 |first= Zoltan
 |last2= Henderson |first2= Fergus |last3= Conway |first3= Thomas
 |title= The execution algorithm of Mercury: an efficient purely declarative logic programming language
 |journal= Journal of Logic Programming
 |volume= 29
 |issue= 1–3
 |pages= 17–64
 |publisher= Mercurylang.org
 |date= October–December 1996
 |url= http://www.mercurylang.org/documentation/papers.html#jlp
 |doi= 10.1016/S0743-1066(96)00068-4
 |access-date = 2008-08-30|citeseerx=10.1.1.46.9861}}</ref> Its authors claim that Mercury is the fastest logic language in the world, by a wide margin.<ref name="motivation"/>

Mercury is a purely [[Declarative programming|declarative]] language, unlike [[Prolog]], since it lacks ''extra-logical'' Prolog statements such as <code>!</code> (cut) and [[imperative programming|imperative]] [[input/output]] (I/O). This enables advanced [[static program analysis]] and [[program optimization]], including compile-time [[Garbage collection (computer science)|garbage collection]],<ref>{{cite thesis
|url=https://mercurylang.org/documentation/papers/CW2004_03_mazur.pdf
|title=Compile-time garbage collection for the declarative language Mercury
|first=Nancy |last=Mazur |date=May 2004 |publisher=Katholieke Universiteit Leuven}}</ref> but it can make certain programming constructs (such as a switch over a number of options, with a default{{Dubious|Examples_of_difficulties_introduced_by_declarativeness.3F|date=February 2009}}) harder to express. While Mercury does allow impure functionality, it serves mainly as a way to call foreign language code. All impure code must be explicitly marked. Operations which would typically be impure (such as [[input/output]]) are expressed using pure constructs in Mercury using [[Linear type system|linear types]], by threading a dummy ''world'' value through all relevant code.

Notable programs written in Mercury include the Mercury compiler and the [[Prince XML]] formatter. The Software company ODASE has also been using Mercury to develop its Ontology-Centric software development platform, ODASE.<ref>[https://www.odase.io/ ODASE]</ref>

==Back-ends==
Mercury has several back-ends, which enable compiling Mercury code into several languages, including:

===Production level===
* Low-level [[C (programming language)|C]] for [[GNU Compiler Collection]] (GCC), the original Mercury back-end
* High-level C
* [[Java (programming language)|Java]]
* [[C Sharp (programming language)|C#]]

===Past===
* [[Assembly language]] via the GCC back-end
* Aditi, a deductive database system also developed at the [[University of Melbourne]]. Mercury-0.12.2 is the last version to support Aditi.{{citation needed|date=January 2014}}
* [[Common Intermediate Language]] (CIL) for the [[.NET Framework]]
* [[Erlang (programming language)|Erlang]]

Mercury also features a foreign language interface, allowing code in other languages (depending on the chosen back-end) to be linked with Mercury code. The following foreign languages are possible:
{| class="wikitable"
! Back-end !! Foreign language(s)
|-
| C (both levels)
| [[C (programming language)|C]]
|-
| Java
| [[Java (programming language)|Java]]
|-
| Erlang
| [[Erlang (programming language)|Erlang]]
|-
| IL
| [[Common Intermediate Language]] (CIL) or [[C Sharp (programming language)|C#]]
|}

Other languages can then be interfaced to by calling them from these languages.  However, this means that foreign language code may need to be written several times for the different backends, otherwise portability between backends will be lost.

The most commonly used back-end is the original low-level C back-end.

== Examples ==
[[Hello world program|Hello World]]:
<syntaxhighlight lang="prolog">
 :- module hello.
 :- interface.
 :- import_module io.
 :- pred main(io::di, io::uo) is det.

 :- implementation.
 main(!IO) :-
 	io.write_string("Hello, World!\n", !IO).
</syntaxhighlight>

Calculating the 10th [[Fibonacci number]] (in the most obvious way):<ref name="tutorial">Adapted from [http://www.mercurylang.org/documentation/papers/book.pdf Ralph Becket's Mercury tutorial]</ref>
<syntaxhighlight lang="prolog">
 :- module fib.
 :- interface.
 :- import_module io.
 :- pred main(io::di, io::uo) is det.
 
 :- implementation.
 :- import_module int.

 :- func fib(int) = int.
 fib(N) = (if N =< 2 then 1 else fib(N - 1) + fib(N - 2)).

 main(!IO) :-
        io.write_string("fib(10) = ", !IO),
        io.write_int(fib(10), !IO),
        io.nl(!IO).
        % Could instead use io.format("fib(10) = %d\n", [i(fib(10))], !IO).
</syntaxhighlight>
<code>!IO</code> is a "state variable", which is [[syntactic sugar]] for a pair of variables which are assigned concrete names at compilation; for example, the above is desugared to something like:
<syntaxhighlight lang="prolog">
 main(IO0, IO) :-
        io.write_string("fib(10) = ", IO0, IO1),
        io.write_int(fib(10), IO1, IO2),
        io.nl(IO2, IO).
</syntaxhighlight>

==Release schedule==
The stable release naming scheme was 0.1 up to 0.13 for the first thirteen stable releases. In February 2010 the Mercury project decided to name each stable release by using the year and month of the release. For example 10.04 is for a release made in April 2010.

There is often also a periodic snapshot of the development system ''release of the day'' (ROTD)

==IDE and editor support==
* Developers provide support for [[Vim (text editor)|Vim]]
* Flycheck library for [[Emacs]]
* A plugin is available for the [[Eclipse (software)|Eclipse IDE]]
* A plugin is available for the [[NetBeans|NetBeans IDE]]

==See also==
{{Portal|Free and open-source software}}
* [[Curry (programming language)|Curry]], another functional logic language
* [[Alice (programming language)|Alice]], a dialect language of [[Standard ML]]
* [[Logtalk]], language, an object-oriented extension of Prolog which compiles down to Prolog
* [[Oz (programming language)|Oz/Mozart]], a multiparadigm language
* [[Visual Prolog]], language, a strongly typed object-oriented extension of Prolog, with a new syntax

==References==
{{Reflist}}

==External links==
* {{Official website|www.mercurylang.org}}

{{DEFAULTSORT:Mercury (programming language)}}
[[Category:Cross-platform free software]]
[[Category:Functional logic programming languages]]
[[Category:.NET programming languages]]
[[Category:Programming languages created in 1995]]
[[Category:Statically typed programming languages]]