<div dir="ltr"><div>Update release notes for 13.05 release.</div><div><br></div><div>RELEASE_NOTES:</div><div><span class="" style="white-space:pre"> </span>Mercury now works on 64-bit Windows.</div><div><br></div><div><span class="" style="white-space:pre"> </span>Update email and web addresses for the project.</div>
<div><br></div><div><span class="" style="white-space:pre"> </span>The distribution is no longer split into three parts.</div><div><br></div><div><span class="" style="white-space:pre"> </span>Mention that we have a module for doing arithmetic on</div>
<div><span class="" style="white-space:pre"> </span>fixed-point numbers.</div><div><br></div><div><span class="" style="white-space:pre"> </span>Mention the GLFW binding.</div><div><span class="" style="white-space:pre"> </span></div>
<div><span class="" style="white-space:pre"> </span>The Mercury team are no longer at the University of</div><div><span class="" style="white-space:pre"> </span>Melbourne. (And the CSSE departement no longer exists</div>
<div><span class="" style="white-space:pre"> </span>by that name, anyway.)</div><div><br></div><div>Julien.</div><div><br></div><div>diff --git a/RELEASE_NOTES b/RELEASE_NOTES</div><div>index 5504ac2..69531b7 100644</div>
<div>--- a/RELEASE_NOTES</div><div>+++ b/RELEASE_NOTES</div><div>@@ -1,5 +1,5 @@</div><div> </div><div>-We are pleased to announce the release of version 12.08 of the Mercury system.</div><div>+We are pleased to announce the release of version 13.05 of the Mercury system.</div>
<div> </div><div> Mercury is a modern general-purpose programming language, designed and</div><div> implemented by a small group of researchers at the University of</div><div>@@ -18,112 +18,112 @@ For a list of what's new in this release, see the NEWS file.</div>
<div> The main features of Mercury are:</div><div> </div><div> o Mercury is purely declarative: predicates and functions</div><div>-<span class="" style="white-space:pre"> </span>in Mercury do not have non-logical side effects.</div>
<div>-</div><div>-<span class="" style="white-space:pre"> </span>Mercury does I/O through built-in and library predicates that</div><div>-<span class="" style="white-space:pre"> </span>take an old state of the world and some other parameters, and</div>
<div>-<span class="" style="white-space:pre"> </span>return a new state of the world and possibly some other</div><div>-<span class="" style="white-space:pre"> </span>results. The language requires that the input argument</div>
<div>-<span class="" style="white-space:pre"> </span>representing the old state of the world be the last reference</div><div>-<span class="" style="white-space:pre"> </span>to the old state of the world, thus allowing it the state of</div>
<div>-<span class="" style="white-space:pre"> </span>the world to be updated destructively. The language also</div><div>-<span class="" style="white-space:pre"> </span>requires that I/O take place only in parts of the program where</div>
<div>-<span class="" style="white-space:pre"> </span>backtracking will not be needed.</div><div>-</div><div>-<span class="" style="white-space:pre"> </span>Mercury handles dynamic data structures not through Prolog's</div>
<div>-<span class="" style="white-space:pre"> </span>assert/retract but by providing several abstract data types in</div><div>-<span class="" style="white-space:pre"> </span>the standard Mercury library that manage collections of items</div>
<div>-<span class="" style="white-space:pre"> </span>with different operations and tradeoffs.</div><div>+ in Mercury do not have non-logical side effects.</div><div>+</div><div>+ Mercury does I/O through built-in and library predicates that</div>
<div>+ take an old state of the world and some other parameters, and</div><div>+ return a new state of the world and possibly some other</div><div>+ results. The language requires that the input argument</div>
<div>+ representing the old state of the world be the last reference</div><div>+ to the old state of the world, thus allowing it the state of</div><div>+ the world to be updated destructively. The language also</div>
<div>+ requires that I/O take place only in parts of the program where</div><div>+ backtracking will not be needed.</div><div>+</div><div>+ Mercury handles dynamic data structures not through Prolog's</div>
<div>+ assert/retract but by providing several abstract data types in</div><div>+ the standard Mercury library that manage collections of items</div><div>+ with different operations and tradeoffs.</div>
<div> </div><div> o Mercury is a strongly typed language. Mercury's type system is</div><div>-<span class="" style="white-space:pre"> </span>based on many-sorted logic with parametric polymorphism, very</div><div>
-<span class="" style="white-space:pre"> </span>similar to the type systems of modern functional languages such</div><div>-<span class="" style="white-space:pre"> </span>as ML and Haskell. Programmers must declare the types they</div>
<div>-<span class="" style="white-space:pre"> </span>need using declarations such as</div><div>+ based on many-sorted logic with parametric polymorphism, very</div><div>+ similar to the type systems of modern functional languages such</div>
<div>+ as ML and Haskell. Programmers must declare the types they</div><div>+ need using declarations such as</div><div> </div><div>-<span class="" style="white-space:pre"> </span>:- type list(T) ---><span class="" style="white-space:pre"> </span>[] ; [T | list(T)].</div>
<div>-<span class="" style="white-space:pre"> </span>:- type maybe(T) ---><span class="" style="white-space:pre"> </span>yes(T) ; no.</div><div>+ :- type list(T) ---> [] ; [T | list(T)].</div><div>+ :- type maybe(T) ---> yes(T) ; no.</div>
<div> </div><div>-<span class="" style="white-space:pre"> </span>They must also declare the type signatures of the predicates and</div><div>-<span class="" style="white-space:pre"> </span>functions they define, for example</div>
<div>+ They must also declare the type signatures of the predicates and</div><div>+ functions they define, for example</div><div> </div><div>-<span class="" style="white-space:pre"> </span>:- pred append(list(T), list(T), list(T)).</div>
<div>+ :- pred append(list(T), list(T), list(T)).</div><div> </div><div>-<span class="" style="white-space:pre"> </span>The compiler infers the types of all variables in the program.</div><div>-<span class="" style="white-space:pre"> </span>Type errors are reported at compile time.</div>
<div>+ The compiler infers the types of all variables in the program.</div><div>+ Type errors are reported at compile time.</div><div> </div><div> o Mercury is a strongly moded language. The programmer must</div>
<div>-<span class="" style="white-space:pre"> </span>declare the instantiation state of the arguments of predicates</div><div>-<span class="" style="white-space:pre"> </span>at the time of the call to the predicate and at the time of the</div>
<div>-<span class="" style="white-space:pre"> </span>success of the predicate. Currently only a subset of the</div><div>-<span class="" style="white-space:pre"> </span>intended mode system is implemented. This subset effectively</div>
<div>-<span class="" style="white-space:pre"> </span>requires arguments to be either fully input (ground at the time</div><div>-<span class="" style="white-space:pre"> </span>of call and at the time of success) or fully output (free at</div>
<div>-<span class="" style="white-space:pre"> </span>the time of call and ground at the time of success).</div><div>+ declare the instantiation state of the arguments of predicates</div><div>+ at the time of the call to the predicate and at the time of the</div>
<div>+ success of the predicate. Currently only a subset of the</div><div>+ intended mode system is implemented. This subset effectively</div><div>+ requires arguments to be either fully input (ground at the time</div>
<div>+ of call and at the time of success) or fully output (free at</div><div>+ the time of call and ground at the time of success).</div><div> </div><div>-<span class="" style="white-space:pre"> </span>A predicate may be usable in more than one mode. For example,</div>
<div>-<span class="" style="white-space:pre"> </span>append is usually used in at least these two modes:</div><div>+ A predicate may be usable in more than one mode. For example,</div><div>+ append is usually used in at least these two modes:</div>
<div> </div><div>-<span class="" style="white-space:pre"> </span>:- mode append(in, in, out).</div><div>-<span class="" style="white-space:pre"> </span>:- mode append(out, out, in).</div><div>+ :- mode append(in, in, out).</div>
<div>+ :- mode append(out, out, in).</div><div> </div><div>-<span class="" style="white-space:pre"> </span>If a predicate has only one mode, the mode information can be</div><div>-<span class="" style="white-space:pre"> </span>given in the predicate declaration.</div>
<div>+ If a predicate has only one mode, the mode information can be</div><div>+ given in the predicate declaration.</div><div> </div><div>-<span class="" style="white-space:pre"> </span>:- pred factorial(int::in, int::out).</div>
<div>+ :- pred factorial(int::in, int::out).</div><div> </div><div>-<span class="" style="white-space:pre"> </span>The compiler will infer the mode of each call, unification and</div><div>-<span class="" style="white-space:pre"> </span>other builtin in the program. It will reorder the bodies of</div>
<div>-<span class="" style="white-space:pre"> </span>clauses as necessary to find a left to right execution order;</div><div>-<span class="" style="white-space:pre"> </span>if it cannot do so, it rejects the program. Like type-checking,</div>
<div>-<span class="" style="white-space:pre"> </span>this means that a large class of errors are detected at</div><div>-<span class="" style="white-space:pre"> </span>compile time.</div><div>+ The compiler will infer the mode of each call, unification and</div>
<div>+ other builtin in the program. It will reorder the bodies of</div><div>+ clauses as necessary to find a left to right execution order;</div><div>+ if it cannot do so, it rejects the program. Like type-checking,</div>
<div>+ this means that a large class of errors are detected at</div><div>+ compile time.</div><div> </div><div> o Mercury has a strong determinism system. For each mode of each</div><div>-<span class="" style="white-space:pre"> </span>predicate, the programmer should declare whether the predicate</div>
<div>-<span class="" style="white-space:pre"> </span>will succeed exactly once (det), at most once (semidet), at</div><div>-<span class="" style="white-space:pre"> </span>least once (multi) or an arbitrary number of times (nondet).</div>
<div>-<span class="" style="white-space:pre"> </span>These declarations are attached to mode declarations like</div><div>-<span class="" style="white-space:pre"> </span>this:</div><div>-</div><div>-<span class="" style="white-space:pre"> </span>:- mode append(in, in, out) is det.</div>
<div>-<span class="" style="white-space:pre"> </span>:- mode append(out, out, in) is multi.</div><div>-</div><div>-<span class="" style="white-space:pre"> </span>:- pred factorial(int::in, int::out) is det.</div><div>-</div>
<div>-<span class="" style="white-space:pre"> </span>The compiler will try to prove the programmer's determinism</div><div>-<span class="" style="white-space:pre"> </span>declaration using a simple, predictable set of rules that seems</div>
<div>-<span class="" style="white-space:pre"> </span>sufficient in practice (the problem in general is undecidable).</div><div>-<span class="" style="white-space:pre"> </span>If it cannot do so, it rejects the program.</div>
<div>-</div><div>-<span class="" style="white-space:pre"> </span>As with types and modes, determinism checking catches many</div><div>-<span class="" style="white-space:pre"> </span>program errors at compile time. It is particularly useful if</div>
<div>-<span class="" style="white-space:pre"> </span>some deterministic (det) predicates each have a clause for each</div><div>-<span class="" style="white-space:pre"> </span>function symbol in the type of one of their input arguments,</div>
<div>-<span class="" style="white-space:pre"> </span>and this type changes; you will get determinism errors for all</div><div>-<span class="" style="white-space:pre"> </span>of these predicates, telling you to put in code to cover the</div>
<div>-<span class="" style="white-space:pre"> </span>case when the input argument is bound to the newly added</div><div>-<span class="" style="white-space:pre"> </span>function symbol.</div><div>+ predicate, the programmer should declare whether the predicate</div>
<div>+ will succeed exactly once (det), at most once (semidet), at</div><div>+ least once (multi) or an arbitrary number of times (nondet).</div><div>+ These declarations are attached to mode declarations like</div>
<div>+ this:</div><div>+</div><div>+ :- mode append(in, in, out) is det.</div><div>+ :- mode append(out, out, in) is multi.</div><div>+</div><div>+ :- pred factorial(int::in, int::out) is det.</div>
<div>+</div><div>+ The compiler will try to prove the programmer's determinism</div><div>+ declaration using a simple, predictable set of rules that seems</div><div>+ sufficient in practice (the problem in general is undecidable).</div>
<div>+ If it cannot do so, it rejects the program.</div><div>+</div><div>+ As with types and modes, determinism checking catches many</div><div>+ program errors at compile time. It is particularly useful if</div>
<div>+ some deterministic (det) predicates each have a clause for each</div><div>+ function symbol in the type of one of their input arguments,</div><div>+ and this type changes; you will get determinism errors for all</div>
<div>+ of these predicates, telling you to put in code to cover the</div><div>+ case when the input argument is bound to the newly added</div><div>+ function symbol.</div><div> </div><div> o Mercury has a module system. Programs consist of one or more</div>
<div>-<span class="" style="white-space:pre"> </span>modules. Each module has an interface section that contains</div><div>-<span class="" style="white-space:pre"> </span>the declarations for the types, functions and predicates</div>
<div>-<span class="" style="white-space:pre"> </span>exported from the module, and an implementation section that</div><div>-<span class="" style="white-space:pre"> </span>contains the definitions of the exported entities and also</div>
<div>-<span class="" style="white-space:pre"> </span>definitions for types and predicates that are local to the</div><div>-<span class="" style="white-space:pre"> </span>module. A type whose name is exported but whose definition is</div>
<div>-<span class="" style="white-space:pre"> </span>not, can be manipulated only by predicates in the defining</div><div>-<span class="" style="white-space:pre"> </span>module; this is how Mercury implements abstract data types.</div>
<div>-<span class="" style="white-space:pre"> </span>For predicates and functions that are not exported, Mercury</div><div>-<span class="" style="white-space:pre"> </span>supports automatic type, mode, and determinism inference.</div>
<div>+ modules. Each module has an interface section that contains</div><div>+ the declarations for the types, functions and predicates</div><div>+ exported from the module, and an implementation section that</div>
<div>+ contains the definitions of the exported entities and also</div><div>+ definitions for types and predicates that are local to the</div><div>+ module. A type whose name is exported but whose definition is</div>
<div>+ not, can be manipulated only by predicates in the defining</div><div>+ module; this is how Mercury implements abstract data types.</div><div>+ For predicates and functions that are not exported, Mercury</div>
<div>+ supports automatic type, mode, and determinism inference.</div><div> </div><div> o Mercury supports higher-order programming,</div><div>-<span class="" style="white-space:pre"> </span>with closures, currying, and lambda expressions.</div>
<div>+ with closures, currying, and lambda expressions.</div><div> </div><div> o Mercury is very efficient (in comparison with existing logic</div><div>-<span class="" style="white-space:pre"> </span>programming languages). Strong types, modes, and determinism</div>
<div>-<span class="" style="white-space:pre"> </span>provide the compiler with the information it needs to generate</div><div>-<span class="" style="white-space:pre"> </span>very efficient code.</div><div>+ programming languages). Strong types, modes, and determinism</div>
<div>+ provide the compiler with the information it needs to generate</div><div>+ very efficient code.</div><div> </div><div> The Mercury compiler is written in Mercury itself. It was originally</div><div> bootstrapped using NU-Prolog and SICStus Prolog. This was possible</div>
<div>@@ -144,8 +144,8 @@ The Mercury compiler can also compile Mercury programs to Java, C# or</div><div> Erlang. See README.Java, README.CSharp, and README.Erlang respectively</div><div> for further details.</div><div> </div>
<div>-The current Mercury system has been tested on Linux (x86), Linux (x86_64),</div><div>-Mac OS X (x86 and x86_64), and Windows (x86).</div><div>+The current Mercury system has been tested on Linux (x86 and x86_64),</div>
<div>+Mac OS X (x86 and x86_64), and Windows (x86 and x86_64).</div><div> For Windows, we have tested this release on Windows XP SP3, Windows 7,</div><div> and Windows Server 2008 R2.</div><div> </div><div>@@ -156,17 +156,18 @@ Mac OS X (PowerPc) and Windows 95, 98, ME, NT and 2000.</div>
<div> </div><div> It should run without too many changes on other Unix variants as well.</div><div> If you do encounter any problems, please report them to via the</div><div>-Mercury bug tracking system at <<a href="http://bugs.mercury.csse.unimelb.edu.au">http://bugs.mercury.csse.unimelb.edu.au</a>></div>
<div>+Mercury bug tracking system at <<a href="http://bugs.mercurylang.org">http://bugs.mercurylang.org</a>></div><div> (see the BUGS file).</div><div> </div><div> We recommend that you use gcc as the C compiler, preferably gcc version 3.4 or</div>
<div> later. Do not use gcc versions 2.96, 3.0 or 4.0; those version have bugs that</div><div> cause trouble for Mercury. If you are using gcc, you will need at least</div><div> version 2.95 or higher, except on Mac OS X where you will need version 3.3 or</div>
<div>-higher. You will also need GNU make version 3.69 or higher.</div><div>+higher. Visual C++ or clang may also be used as a C compiler.</div><div>+(See README.MS-VisualC and README.clang for further details.) </div>
<div>+You will also need GNU make version 3.69 or higher.</div><div> </div><div>-The Mercury distribution is split into three parts.</div><div>-The "mercury-compiler" distribution contains:</div><div>+The Mercury distribution contains:</div>
<div> o an autoconfiguration script</div><div> o the Mercury source for the compiler</div><div> o the Mercury source for the standard library</div><div>@@ -177,45 +178,38 @@ The "mercury-compiler" distribution contains:</div>
<div> o an integrated procedural and declarative debugger</div><div> o some profilers</div><div> o some utility programs, including a make front-end for Mercury</div><div>-<span class="" style="white-space:pre"> </span>with automatic dependency recomputation</div>
<div>+ with automatic dependency recomputation</div><div> o the Mercury language reference manual</div><div> o the Mercury library reference manual</div><div> o the Mercury user's guide</div><div>
o the Mercury frequently asked questions list</div><div> o the Prolog to Mercury transition guide</div><div> o some sample Mercury programs</div><div>-</div><div>-The "mercury-extras" distribution contains some extra libraries for:</div>
<div> o dynamic linking</div><div> o backtrackable (trailed) destructive update</div><div> o arithmetic</div><div> - arithmetic on complex and imaginary numbers</div><div>+ - arithmetic on fixed-point numbers</div>
<div> o UIs:</div><div>- - graphics using Tk, OpenGL/GLUT, Xlib, Allegro or Cairo.</div><div>+ - graphics using Tk, OpenGL, GLUT, GLFW, Xlib, Allegro or Cairo.</div><div> - text interfaces using curses</div>
<div> - processing HTML forms using the CGI interface</div><div> o interfacing:</div><div> - XML parsing</div><div> - POSIX interface</div><div> - an ODBC database interface</div>
<div>-and</div><div> o the Morphine trace analysis system</div><div> o a general purpose lexer</div><div> o Moose, a parser generator for Mercury.</div><div> </div><div>-The "mercury-tests" distribution contains a test suite.</div>
<div>-</div><div>-The three components of the Mercury distribution are available</div><div>-via anonymous ftp or WWW from the following locations:</div><div>+The Mercury distribution is available via WWW from the following locations:</div>
<div> </div><div>-<span class="" style="white-space:pre"> </span>Australia:</div><div>-<span class="" style="white-space:pre"> </span><a href="ftp://ftp.mercury.csse.unimelb.edu.au/pub/mercury">ftp://ftp.mercury.csse.unimelb.edu.au/pub/mercury</a></div>
<div>+ Australia:</div><div>+ <<a href="http://dl.mercurylang.org/index.html">http://dl.mercurylang.org/index.html</a>></div><div> </div><div> The home page of the project on the Web is:</div><div>
</div><div>- <<a href="http://www.mercury.csse.unimelb.edu.au">http://www.mercury.csse.unimelb.edu.au</a>>.</div><div>+ <<a href="http://www.mercurylang.org">http://www.mercurylang.org</a>>.</div><div> </div>
<div> --</div><div>-The Mercury Team <<a href="http://www.csse.unimelb.edu.au/contact/people.html">http://www.csse.unimelb.edu.au/contact/people.html</a>></div><div>-Department of Computer Science and Software Engineering</div>
<div>-The University of Melbourne, Australia</div><div>+The Mercury Team <<a href="http://www.mercurylang.org/contact/people.html">http://www.mercurylang.org/contact/people.html</a>></div><div><br></div></div>