Mercury (programming language)#Examples

Mercury is based on the logic programming language Prolog. It has the same syntax and the same basic concepts such as the 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 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 static type and mode system 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.[http://www.mercurylang.org/about/benchmarks.html The Mercury Project - Benchmarks]{{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}} Its authors claim that Mercury is the fastest logic language in the world, by a wide margin.

Mercury is a purely declarative language, unlike Prolog, since it lacks extra-logical Prolog statements such as ! (cut) and imperative input/output (I/O). This enables advanced static program analysis and program optimization, including compile-time garbage collection,{{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}} 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 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.[https://www.odase.io/ ODASE]

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

• Low-level C for GNU Compiler Collection (GCC), the original Mercury back-end
• High-level C
• Java
• C#

• 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

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:

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.

Hello World:

:- module hello.

:- interface.

:- import_module io.

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

:- implementation.

main(!IO) :-

io.write_string("Hello, World!\n", !IO).

Calculating the 10th Fibonacci number (in the most obvious way):Adapted from [http://www.mercurylang.org/documentation/papers/book.pdf Ralph Becket's Mercury tutorial]

:- 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).

!IO 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:

main(IO0, IO) :-

io.write_string("fib(10) = ", IO0, IO1),

io.write_int(fib(10), IO1, IO2),

io.nl(IO2, IO).

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)

• Developers provide support for Vim
• Flycheck library for Emacs
• A plugin is available for the Eclipse IDE
• A plugin is available for the NetBeans IDE

{{Portal|Free and open-source software}}

• Curry, another functional logic language
• Alice, a dialect language of Standard ML
• Logtalk, language, an object-oriented extension of Prolog which compiles down to Prolog
• Oz/Mozart, a multiparadigm language
• Visual Prolog, language, a strongly typed object-oriented extension of Prolog, with a new syntax

{{Reflist}}

• {{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