<!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" lang="" xml:lang=""> <head> <meta charset="utf-8" /> <meta name="generator" content="pandoc" /> <meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes" /> <title>NEWS</title> <style type="text/css"> code{white-space: pre-wrap;} span.smallcaps{font-variant: small-caps;} span.underline{text-decoration: underline;} div.column{display: inline-block; vertical-align: top; width: 50%;} </style>  </head> <body> <h1 id="news-since-mercury-14.01.x">NEWS since Mercury 14.01.x</h1> <h2 id="changes-that-may-break-compatibility">Changes that may break compatibility</h2> <ul> <li><p>When the Mercury compiler looks at code using Mercury keywords (such as <code>"func"</code> and <code>"pred"</code>) and Mercury operators (such as clause neck operator <code>":-"</code>) but which cannot be parsed as the Mercury constructs that those Mercury keywords and operators are part of, it now generates a specific error message for each discrepancy. In the past, when it found such code, the compiler considered such code to construct terms and/or to call functions and predicates. Usually, the terms did not belong to any declared type and the called functions and predicates did not exist, leading to confusing error messages from the compiler.</p> <p>The compiler's new approach generates considerably better diagnostics, but it does mean that code that uses Mercury's keywords and/or operators in ways that are inconsistent with Mercury's own uses of those keywords and operators will not compile anymore. Such code will need to be changed, typically by changing the names of some function symbols, functions or predicates.</p></li> <li><p>Code that switches on a field of a term could previously written directly as</p> <pre><code>( Term ^ field = value1, ... ; Term ^ field = value2, ... )</code></pre> <p>The compiler would then internally rearrange this as</p> <pre><code>Field = Term ^ field, ( Field = value1, ... ; Field = value2, ... )</code></pre> <p>and then recognize this as a switch on <code>Field</code>.</p> <p>However, it turns out that while this transformation is valid in the vast majority of cases (well in excess of 99%), it is not valid in some rare circumstances involving terms with unique arguments. This means that the current version of the compiler is not allowed to do the above transformation automatically, so programmers must perform it themselves if needed.</p></li> <li><p>We have enabled stricter checking of non-ground final insts to reject more mode-incorrect code. Due to compiler limitations, some code that should be accepted will now be rejected. They will require modifications to appease the compiler.</p></li> <li><p>We have enabled stricter checking of the requirement that a type, inst or a mode that is <em>not</em> exported from a module may not be used in the declarations of entities (such as predicates and typeclasses) that <em>is</em> exported from that module. This may require the explicit export of e.g. some types that previously were not exported.</p></li> <li><p>We have enabled stricter checking of type declarations and definitions: all declarations and definitions of a type must agree on whether the type is a solver type or not, and the definitions (as opposed to the names) of solver types may not be exported from their defining module.</p></li> <li><p>We have enabled stricter checking of module accessibility rules. If a module <code>m</code> has an <code>import_module</code> or <code>use_module</code> declaration for module <code>x.y.z</code>, it must also have <code>import_module</code> or <code>use_module</code> declarations for its ancestors <code>x</code> and <code>x.y</code>. And if the import or use of <code>x.y.z</code> is in module <code>m</code>'s interface, then the import or use of <code>x.y.z</code>'s ancestor modules must also be in the interface.</p></li> <li><p>References to everything imported via <code>:- use_module</code> declarations must now be fully module qualified.</p></li> <li><p><code>for</code> is now an operator.</p></li> <li><p>It is now an error for a program to redefine a builtin type. The affected type names are:</p> <pre><code>int int{8,16,32,64} uint uint{8,16,32,64} float character string {} = pred func pure semipure impure ''</code></pre></li> <li><p>It is now an error for a program to redefine a builtin inst. The affected inst names are:</p> <pre><code>=< any bound bound_unique clobbered clobbered_any free ground is mostly_clobbered mostly_unique mostly_unique_any not_reached unique unique_any</code></pre></li> <li><p>It is now an error for a program to redefine a builtin mode. The affected mode names are:</p> <pre><code>= >> any_func any_pred func is pred</code></pre></li> <li><p>We have deleted the builtin inst synonyms <code>old</code> and <code>new</code>: their uses should be replaced with <code>any</code> and <code>free</code> respectively.</p></li> <li><p>We have deleted the builtin modes <code>no</code> and <code>oo</code>: their uses should be replaced with <code>oa</code> and <code>ia</code> respectively.</p></li> <li><p>The minimum version of the Java platform required by Mercury's Java backend is now Java SE 8.</p></li> <li><p>The representation of integer constants in the standard library's <code>term</code> and <code>lexer</code> modules has been generalised. The base, signedness and size of each integer constant is now recorded. Furthermore, these modules now use arbitrary-precision integers to represent the values of integer constants.</p> <p>Code that relies on the old representation of integer constants used by the <code>term</code> or <code>lexer</code> modules may use the <code>old_term_parser</code> library in the extras instead.</p></li> <li><p>We have changed the semantics of <code>int.(<<)</code> and <code>int.(>>)</code> so that they throw an exception if their second operand is not in [0, bits_per_int). For now, the old behaviour of these operations is provided by the functions <code>int.legacy_left_shift</code>/2 and <code>int.legacy_right_shift</code>/2. These functions will be deleted in a future release.</p></li> <li><p>We have changed the semantics of <code>int.abs</code>/1 so that it throws an exception if its argument is equal to <code>int.min_int</code>. The old behaviour of this function is provided by the new function <code>int.unchecked_abs</code>/1.</p></li> <li><p>We have changed the semantics of <code>array.map_corresponding_foldl</code>/6 so that it throws an exception if the input arrays differ in size.</p></li> <li><p>We have changed the semantics of <code>array.shrink</code>/3 and <code>array.resize</code>/4 so that they throw an exception if their first argument is negative.</p></li> <li><p>We have changed the semantics of <code>array.fetch_items</code>/4 so that it always throws an exception if its second or third argument is out of bounds. Previously, it would return an empty if list if its third argument was less than the second even if one, or both, of these arguments was out of bounds.</p></li> <li><p>We have removed the <code>io.poly_type</code> equivalence type from the <code>io</code> module. <code>string.poly_type</code> should be used directly. This may require an explicit import of the <code>string</code> module.</p></li> </ul> <h2 id="changes-to-the-mercury-language">Changes to the Mercury language</h2> <ul> <li><p>We have added nine new primitive types: <code>uint</code>, <code>int8</code>, <code>int16</code>, <code>int32</code>, <code>int64</code>, <code>uint8</code>, <code>uint16</code>, <code>uint32</code> and <code>uint64</code>. The type <code>uint</code> is an unsigned integer type of the same size as Mercury's <code>int</code> type; the types <code>int8</code>, <code>int16</code>, <code>int32</code> and <code>int64</code> are signed integer types of width 8, 16, 32 and 64 bits respectively; the types <code>uint8</code>, <code>uint16</code>, <code>uint32</code> and <code>uint64</code> are unsigned integer types of width 8, 16, 32 and 64 bits respectively.</p> <p>Literals of these new types must have a distinguishing suffix, for example:</p> <pre><code>999u 561i32 0b1111100111i64 0o16u8 0x3e732i64</code></pre> <p>Basic operations on the new primitive types are provided by the new standard library modules: <code>uint</code>, <code>int8</code>, <code>int16</code>, <code>int32</code>, <code>int64</code>, <code>uint8</code>, <code>uint16</code>, <code>uint32</code> and <code>uint64</code>.</p></li> <li><p>We have added a new kind of scope to the language: determinism checks for switch arms. These scopes are introduced by any of the new keywords</p> <pre><code>require_switch_arms_det require_switch_arms_semidet require_switch_arms_multi require_switch_arms_nondet require_switch_arms_cc_multi require_switch_arms_cc_nondet require_switch_arms_erroneous require_switch_arms_failure</code></pre> <p><code>require_switch_arms_<determinism> [Var] Goal</code> tells the compiler to require <code>Goal</code> to be a switch on <code>Var</code> in which all the switch arms have determinisms at least as tight as <code><determinism></code>, and to generate error messages for any violations of this requirement.</p></li> <li><p>We have changed the meaning of <code>require_complete_switch</code> scopes slightly: the compiler now generates an error if the goal inside the scope is not a switch on the named variable.</p></li> <li><p>We have added a new kind of scope to the language for disabling warnings within the scope. A goal such as</p> <pre><code>disable_warnings [singleton_vars] ( Goal )</code></pre> <p>is equivalent to <code>Goal</code>, with the exception that the compiler will not generate warnings about singleton variables inside <code>Goal</code>.</p></li> <li><p>We have added an extension to include external files in <code>pragma foreign_decl</code> and <code>pragma foreign_code</code> declarations.</p></li> <li><p>We have added a foreign type assertion <code>word_aligned_pointer</code> that allows the Mercury implementation to avoid boxing values of the foreign type that the assertion is for when the type appears as the sole argument of a data constructor.</p></li> <li><p>We have added a new pragma named <code>consider_used</code>. This pragma tells the compiler to consider the predicate or function it names to be used, preventing it from generating unused procedure warnings either for any of its procedures, or for any of the procedures they call, directly or indirectly.</p></li> <li><p>We have added an optional second field to the <code>obsolete</code> pragma. When present, it may contain a list of the names and arities of predicates and/or functions that programmers should consider using instead of the obsolete predicate or function.</p></li> <li><p>We have added an <code>obsolete_proc</code> pragma. While the <code>obsolete</code> pragma declares all modes of a predicate or function to be obsolete, the <code>obsolete_proc</code> pragma declares only one mode of a predicate or function to be obsolete. Like the updated version of the <code>obsolete</code> pragma, the <code>obsolete_proc</code> pragma may have a second argument naming one or more suggested replacements.</p></li> <li><p>The Java backend now supports defining foreign types as primitive Java types.</p></li> <li><p>Digits in numeric literals may now be separated by underscores in order to improve readability.</p></li> </ul> <h2 id="changes-to-the-mercury-standard-library">Changes to the Mercury standard library</h2> <h3 id="new-integer-modules">New Integer Modules</h3> <ul> <li><p>We have added the new modules <code>uint</code>, <code>int8</code>, <code>int16</code>, <code>int32</code>, <code>int64</code>, <code>uint8</code>, <code>uint16</code>, <code>uint32</code> and <code>uint64</code>. These modules provide the basic operations on the new integer types.</p> <p>Many other standard library modules now have additional predicates that support the new integer types; see the entries for those modules for details.</p></li> </ul> <h3 id="new-module-diet">New Module: <code>diet</code></h3> <ul> <li>This module provides discrete interval encoding trees, which are a highly efficient set implementation for fat sets. This module is a contribution from Yes Logic Pty. Ltd.</li> </ul> <h3 id="new-module-psqueue">New Module: <code>psqueue</code></h3> <ul> <li>This module implements a priority search queue ADT. This is a blend between a priority queue and a map. This was contributed by Matthias Güdemann.</li> </ul> <h3 id="new-module-ranges">New Module: <code>ranges</code></h3> <ul> <li>This module represents sets of integer using a sort list of ranges. This module export operations that make it particularly suitable for representing domains in finite domain constraint solvers.</li> </ul> <h3 id="new-module-thread.barrier">New Module: <code>thread.barrier</code></h3> <ul> <li>This module provides the <code>barrier</code>/0 type. This type can be used to control progress in concurrent code. This module was contributed by Mission Critical IT.</li> </ul> <h3 id="new-module-thread.future">New Module: <code>thread.future</code></h3> <ul> <li>This module provides the <code>future</code>/0 and <code>future_io</code>/0 types. These type can be used to compute values in parallel using other threads. This module was contributed by Mission Critical IT.</li> </ul> <h3 id="changes-to-the-array-module">Changes to the <code>array</code> module</h3> <ul> <li><p>The following functions and predicates have been added:</p> <ul> <li><code>det_least_index</code>/1</li> <li><code>semidet_least_index</code>/1</li> <li><code>det_greatest_index</code>/1</li> <li><code>semidet_greatest_index</code>/1</li> <li><code>foldl_corresponding</code>/5</li> <li><code>foldl2_corresponding</code>/7</li> <li><code>fill</code>/3</li> <li><code>fill_range</code>/5</li> <li><code>swap</code>/4</li> <li><code>unsafe_swap</code>/4</li> </ul></li> <li><p>The following functions have been deprecated and will be removed in a future release:</p> <ul> <li><code>least_index</code>/1</li> <li><code>greatest_index</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-array2d-module">Changes to the <code>array2d</code> module</h3> <ul> <li><p>The following functions and predicates have been added:</p> <ul> <li><code>is_empty</code>/1</li> <li><code>fill</code>/3</li> <li><code>from_array</code>/3</li> </ul></li> </ul> <h3 id="changes-to-the-assoc_list-module">Changes to the <code>assoc_list</code> module</h3> <ul> <li><p>The following predicate has been added:</p> <ul> <li><code>svremove</code>/4</li> </ul></li> <li><p><code>svremove</code>/4 is like <code>remove</code>/4 but its arguments are in an order more conducive to the use of state variable notation.</p></li> </ul> <h3 id="changes-to-the-bag-module">Changes to the <code>bag</code> module</h3> <ul> <li><p>The following functions and predicates have been added:</p> <ul> <li><code>singleton</code>/1</li> <li><code>insert_duplicates</code>/4</li> <li><code>det_insert_duplicates</code>/4</li> <li><code>det_insert_duplicates</code>/3</li> </ul></li> </ul> <h3 id="changes-to-the-bitmap-module">Changes to the <code>bitmap</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>is_empty</code>/1</li> <li><code>det_from_string</code>/1</li> <li><code>get_uint8</code>/1, <code>unsafe_get_uint8</code>/1</li> <li><code>set_uint8</code>/4, <code>unsafe_set_uint8</code>/4</li> </ul></li> </ul> <h3 id="changes-to-the-builtin-module">Changes to the <code>builtin</code> module</h3> <ul> <li><p>The following predicate and function have been deprecated and will be removed in a future release:</p> <ul> <li><code>promise_only_solution</code>/1</li> <li><code>promise_only_solution_io</code>/4</li> </ul> <p>Existing code that uses either of these should be replaced with code that uses a <code>promise_equivalent_solutions</code> goal instead.</p></li> <li><p>The following modes have been deprecated and will be removed in a future release:</p> <ul> <li><code>input</code>/0</li> <li><code>output</code>/0</li> </ul> <p>Existing code that uses these modes should replace their use with <code>in</code> or <code>out</code> respectively.</p></li> </ul> <h3 id="changes-to-the-calendar-module">Changes to the <code>calendar</code> module</h3> <ul> <li><p>The following functions and predicates have been added:</p> <ul> <li><code>int_to_month</code>/2</li> <li><code>det_int_to_month</code>/1</li> <li><code>int0_to_month</code>/2</li> <li><code>det_int0_to_month</code>/1</li> <li><code>month_to_int</code>/1</li> <li><code>month_to_int0</code>/1</li> <li><code>same_date</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-char-module">Changes to the <code>char</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>is_ascii</code>/1</li> <li><code>is_decimal_digit</code>/1</li> <li><code>is_base_digit</code>/2</li> <li><code>int_to_binary_digit</code>/2, <code>det_int_to_binary_digit</code>/1</li> <li><code>int_to_octal_digit</code>/2, <code>det_int_to_octal_digit</code>/1</li> <li><code>int_to_decimal_digit</code>/2, <code>det_int_to_decimal_digit</code>/1</li> <li><code>int_to_hex_digit</code>/2, <code>det_int_to_hex_digit</code>/1</li> <li><code>base_int_to_digit</code>/3, <code>det_base_int_to_digit</code>/2</li> <li><code>binary_digit_to_int</code>/2, <code>det_binary_digit_to_int</code>/1</li> <li><code>octal_digit_to_int</code>/2, <code>det_octal_digit_to_int</code>/1</li> <li><code>decimal_digit_to_int</code>/2, <code>det_decimal_digit_to_int</code>/1</li> <li><code>hex_digit_to_int</code>/2, <code>det_hex_digit_to_int</code>/1</li> <li><code>base_digit_to_int</code>/3, <code>det_base_digit_to_int</code>/2</li> <li><code>is_leading_surrogate</code>/1, <code>is_trailing_surrogate</code>/1</li> <li><code>is_control</code>/1, <code>is_space_separator</code>/1, <code>is_paragraph_separator</code>/1</li> <li><code>is_line_separator</code>/1, <code>is_private_use</code>/1</li> </ul></li> <li><p>The following predicates have been deprecated and will either be removed or have their semantics changed in a future release:</p> <ul> <li><code>is_hex_digit</code>/2</li> <li><code>int_to_hex_char</code>/2</li> <li><code>digit_to_int</code>/2</li> <li><code>int_to_digit</code>/2</li> <li><p><code>det_int_to_digit</code>/1, <code>det_int_to_digit</code>/2</p> <p>NOTE: existing code that calls <code>digit_to_int</code>/2 assuming that it will only succeed for decimal digits (0-9) may be broken.</p></li> </ul></li> </ul> <h3 id="changes-to-the-cord-module">Changes to the <code>cord</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>to_list</code>/1 (synonym for the existing <code>list</code>/1 function)</li> <li><code>to_rev_list</code>/1 (synonym for the existing <code>rev_list</code>/1 function)</li> <li><code>rev_cord_list_to_cord</code>/1 (similar to <code>cord_list_to_cord</code>/1)</li> <li><code>rev_cord_list_to_list</code>/1 (similar to <code>cord_list_to_list</code>/1)</li> <li><code>cons</code>/3</li> <li><code>snoc</code>/3</li> <li><code>find_first_match</code>/3</li> </ul></li> </ul> <h3 id="changes-to-the-deconstruct-module">Changes to the <code>deconstruct</code> module</h3> <ul> <li>The predicate <code>functor</code>/4 has been modified so that for character and string data, any control characters in the functor representation are escaped.</li> </ul> <h3 id="changes-to-the-digraph-module">Changes to the <code>digraph</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>return_vertices_in_from_to_order</code>/2</li> <li><code>return_vertices_in_to_from_order</code>/2</li> <li><code>return_sccs_in_from_to_order</code>/1</li> <li><code>return_sccs_in_to_from_order</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-float-module">Changes to the <code>float</code> module</h3> <ul> <li><p>The following predicates and function have been added:</p> <ul> <li><code>is_finite</code>/1</li> <li><code>is_zero</code>/1</li> <li><code>is_infinite</code>/1 (synonym for the existing is_inf/1 predicate)</li> <li><code>is_nan_or_infinite</code>/1 (synonym for the existing is_nan_or_inf/1 predicate)</li> <li><code>infinity</code>/0</li> </ul></li> </ul> <h3 id="changes-to-the-getopt-and-getopt_io-modules">Changes to the <code>getopt</code> and <code>getopt_io</code> modules</h3> <ul> <li>We have added variants of the <code>process_options</code> predicates that return errors using a type instead of strings. A new function, <code>option_error_to_string</code>/1, can be used to convert values of the new error type into strings.</li> </ul> <h3 id="changes-to-the-hash_table-module">Changes to the <code>hash_table</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>fold2</code>/6</li> <li><code>fold3</code>/8</li> </ul></li> </ul> <h3 id="changes-to-the-int-module">Changes to the <code>int</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>all_true_in_range</code>/3</li> <li><code>unchecked_abs</code>/1</li> <li><code>nabs</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-integer-module">Changes to the <code>integer</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>from_string</code>/2</li> <li><code>from_base_string</code>/3</li> <li><code>to_int</code>/2</li> <li><code>det_to_int</code>/1</li> <li><code>to_base_string</code>/2</li> <li><code>negative_one</code>/0, <code>two</code>/0, <code>ten</code>/0</li> <li><code>is_zero</code>/1</li> <li><code>to_uint</code>/2</li> <li><code>det_to_uint</code>/1</li> <li><code>from_uint</code>/1</li> <li><code>to_int{8,16,32,64}</code>/2</li> <li><code>det_to_int{8,16,32,64}</code>/1</li> <li><code>from_int{8,16,32,64}</code>/1</li> <li><code>to_uint{8,16,32,64}</code>/2</li> <li><code>det_to_uint{8,16,32,64}</code>/1</li> <li><code>from_uint{8,16,32,64}</code>/1</li> </ul></li> <li><p>The following functions have been deprecated and will be removed in a future release:</p> <ul> <li><code>from_string</code>/1</li> <li><code>from_base_string</code>/2</li> <li><code>int</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-io-module">Changes to the <code>io</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>write_uint/3</code>, <code>write_uint</code>/4</li> <li><code>write_int{8,16,32,64}</code>/3, <code>write_int{8,16,32,64}</code>/4</li> <li><code>write_uint{8,16,32,64}</code>/3, <code>write_uint{8,16,32,64}</code>/4</li> <li><code>write_binary_int8</code>/3, <code>write_binary_int8</code>/4</li> <li><code>write_binary_uint8</code>/3, <code>write_binary_uint8</code>/4</li> <li><code>write_binary_int{16,32,64}</code>/3, <code>write_binary_int{16,32,64}</code>/4</li> <li><code>write_binary_int{16,32,64}_{le,be}</code>/3, <code>write_binary_int{16,32,64}_{le,be}</code>/4</li> <li><code>read_binary_int8</code>/3, <code>read_binary_int8</code>/4</li> <li><code>read_binary_uint8</code>/3, <code>read_binary_uint8</code>/4</li> <li><code>putback_int8</code>/3, <code>putback_int8</code>/4</li> <li><code>putback_uint8</code>/3, <code>putback_uint8</code>/4</li> <li><code>read_binary_int{16,32,64}</code>/3, <code>read_binary_int{16,32,64}</code>/4</li> <li><code>read_binary_int{16,32,64}_{le,be}</code>/3, <code>read_binary_int{16,32,64}_{le,be}</code>/4</li> <li><code>read_binary_uint{16,32,64}</code>/3, <code>read_binary_uint{16,32,64}</code>/4</li> <li><code>read_binary_uint{16,32,64}_{le,be}</code>/3, <code>read_binary_uint{16,32,64}_{le,be}</code>/4</li> <li><code>read_line_as_string_and_num_code_units</code>/[34]</li> <li><code>print_line</code>/[34], <code>write_line</code>/[34]</li> <li><code>write_array</code>/[56] (similar to <code>write_list</code> but for arrays)</li> <li><code>temp_directory</code>/3</li> <li><code>make_temp_directory</code>/3</li> <li><code>make_temp_directory</code>/5</li> <li><code>set_environment_var</code>/5</li> <li><code>have_set_environment_var</code>/0</li> </ul></li> <li><p>The <code>print_line</code> and <code>write_line</code> family of predicates behave like the <code>print</code> and <code>write</code> predicates, but also write a terminating newline.</p></li> <li><p><code>print</code> now outputs arbitrary precision integers in their decimal form instead of printing their underlying representation.</p></li> <li><p>The predicate <code>set_environment_var</code>/5 returns an <code>io.res</code> value rather than throwing an exception. The predicate <code>have_set_environment_var</code>/0 can test whether the current platform supports the ability to set environment variables.</p></li> <li><p>We have made the following predicates exception safe: the current input or output stream is restored to the original stream if an exception is thrown during their execution:</p> <ul> <li><code>read/4</code></li> <li><code>write_list/6</code></li> <li><code>write_array/6</code></li> <li><code>read_binary/4</code></li> <li><code>write_binary/4</code></li> </ul></li> </ul> <h3 id="changes-to-the-lexer-module">Changes to the <code>lexer</code> module</h3> <ul> <li>We have added predicates that read from an explicitly specified input stream, not from the current input stream.</li> </ul> <h3 id="changes-to-the-list-module">Changes to the <code>list</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>any_true</code>/2</li> <li><code>any_false</code>/2</li> <li><code>reverse_prepend</code>/2</li> <li><code>reverse_prepend</code>/3</li> <li><code>take_while</code>/4</li> <li><code>take_while</code>/3</li> <li><code>take_while</code>/2</li> <li><code>drop_while</code>/3</li> <li><code>drop_while</code>/2</li> <li><code>one_or_more_to_list</code>/1</li> <li><code>list_to_one_or_more</code>/2</li> <li><code>list_to_one_or_more_det</code>/2</li> </ul></li> <li><p>The following predicate has been deprecated and will be remove in a future release:</p> <ul> <li><code>takewhile</code>/4 (use <code>take_while</code>/4 instead)</li> </ul></li> <li><p>The <code>take</code>/3 and <code>drop</code>/3 predicates have been modified so that they fail if their first argument is less than zero.</p></li> <li><p>The <code>split_upto</code>/4 and <code>take_upto</code>/3 predicates and <code>take_upto</code>/2 function have been modified so that they throw an exception if their first argument is negative.</p></li> </ul> <h3 id="changes-to-the-map-module">Changes to the <code>map</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>foldl5</code>/12</li> <li><code>foldr5</code>/12</li> <li><code>map_foldl4</code>/11</li> <li><code>intersect_list</code>/4</li> <li><code>union_list</code>/4</li> <li><code>select_unselect</code>/4</li> <li><code>select_unselect_sorted_list</code>/4</li> </ul></li> </ul> <h3 id="changes-to-the-math-module">Changes to the <code>math</code> module</h3> <ul> <li><p>The following function and predicate have been added:</p> <ul> <li><code>fma</code>/3</li> <li><code>have_fma</code>/0</li> </ul></li> <li><p><code>fma</code>/3 provides the fused multiply-add operation on platforms that support that operation. The predicate <code>have_fma</code>/0 may be used to check for this support.</p></li> </ul> <h3 id="changes-to-the-maybe-module">Changes to the <code>maybe</code> module</h3> <ul> <li><p>We have a added a new type, <code>maybe_errors</code>, to the <code>maybe</code> module.</p></li> <li><p>The following predicate and function have been added:</p> <ul> <li><code>fold2_maybe</code>/6</li> <li><code>maybe_default</code>/2</li> <li><code>pred_to_maybe</code>/1</li> <li><code>func_to_maybe</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-parser-module">Changes to the <code>parser</code> module</h3> <ul> <li>We have added predicates that read from an explicitly specified input stream, not from the current input stream.</li> </ul> <h3 id="changes-to-the-pretty_printer-module">Changes to the <code>pretty_printer</code> module</h3> <ul> <li><p>The type <code>formatter_limit</code> has been renamed to <code>func_symbol_limit</code>, since this better reflects the type's purpose.</p></li> <li><p>We have replaced the <code>set_formatter</code> function with a predicate of the same name, since this allows the use of state variable notation when setting up more than one type-specific formatter,</p></li> <li><p>We have renamed the <code>write_doc_to_stream</code> predicate as <code>put_doc</code>, to better fit in with the names other predicates that operate on values of the <code>stream.writer</code> typeclass, and changed its interface to group the prettyprinter parameters together in a value of the type that was designed for this purpose.</p></li> </ul> <h3 id="changes-to-the-rbtree-module">Changes to the <code>rbtree</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>foldl_values</code>/4</li> <li><code>foldl2_values</code>/6</li> </ul></li> </ul> <h3 id="changes-to-the-require-module">Changes to the <code>require</code> module</h3> <ul> <li><p>The following predicate and function have been added:</p> <ul> <li><code>error</code>/2</li> <li><code>func_error</code>/2</li> </ul></li> </ul> <h3 id="changes-to-the-set-module">Changes to the <code>set</code> module</h3> <ul> <li><p>The following predicates and/or functions have been added:</p> <ul> <li><code>intersection_and_differences</code>/5</li> <li><code>det_remove</code>/3</li> <li><code>det_remove_list</code>/3</li> <li><code>rev_sorted_list_to_set</code>/[12]</li> </ul></li> <li><p>The following predicate and/or functions have been deprecated:</p> <ul> <li><code>empty</code>/1</li> <li><code>non_empty</code>/1</li> <li><code>set</code>/1</li> </ul> <p>Similar changes have been made to the other set implementations in the library.</p></li> </ul> <h3 id="changes-to-the-std_util-module">Changes to the <code>std_util</code> module</h3> <ul> <li><p>The following functions have been deprecated:</p> <ul> <li><code>maybe_pred</code>/3</li> <li><code>maybe_func</code>/2</li> </ul></li> </ul> <h3 id="changes-to-the-stream.string_writer-module">Changes to the <code>stream.string_writer</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>put_uint</code>/4</li> <li><code>put_int{8,16,32,64}</code>/4</li> <li><code>put_uint{8,16,32,64}</code>/4</li> </ul></li> <li><p><code>print</code> now outputs arbitrary precision integers in their decimal form instead of printing their underlying representation.</p></li> </ul> <h3 id="changes-to-the-string-module">Changes to the <code>string</code> module</h3> <ul> <li><p>Predicates and functions in this module now have defined behaviours for strings containing ill-formed sequences. Also, some predicates and functions now have defined behaviour on surrogate code points (e.g. failing or throwing an exception) that was previously undefined.</p></li> <li><p>The following predicates have been added:</p> <ul> <li><code>is_all_alnum</code>/1</li> <li><code>is_empty</code>/1</li> <li><code>is_well_formed</code>/1</li> <li><code>from_code_unit_list_allow_ill_formed</code>/2</li> <li><code>to_utf8_code_unit_list</code>/2</li> <li><code>to_utf16_code_unit_list</code>/2</li> <li><code>from_utf8_code_unit_list</code>/2</li> <li><code>from_utf16_code_unit_list</code>/2</li> <li><code>det_remove_prefix</code>/3</li> <li><code>compare_ignore_case_ascii</code>/3</li> <li><code>to_rev_char_list</code>/2</li> <li><code>compare_substrings</code>/6</li> <li><code>unsafe_compare_substrings</code>/6</li> <li><code>nondet_append</code>/3</li> <li><code>append_string_pieces</code>/2</li> <li><code>unsafe_append_string_pieces</code>/2</li> <li><code>unsafe_sub_string_search_start</code>/4</li> <li><code>index_next_repl</code>/5</li> <li><code>unsafe_index_next_repl</code>/5</li> <li><code>prev_index_repl</code>/5</li> <li><code>unsafe_prev_index_repl</code>/5</li> <li><code>uint_to_string</code>/1</li> <li><code>int{8,16,32,64}_to_string</code>/1</li> <li><code>uint{8,16,32,64}_to_string</code>/1</li> </ul></li> <li><p>The following procedures have been deprecated:</p> <ul> <li><code>to_char_list(uo, in)</code></li> <li><code>to_rev_char_list(uo, in)</code></li> <li><code>from_char_list(out, in)</code></li> <li><code>append(out, out, in)</code></li> <li><code>prefix(in, out)</code></li> <li><code>suffix(in, out)</code></li> </ul></li> <li><p>The following obsolete predicates and functions have been removed:</p> <ul> <li><code>substring</code>/3</li> <li><code>substring</code>/4</li> <li><code>unsafe_substring</code>/3</li> <li><code>unsafe_substring</code>/4</li> <li><code>foldl_substring</code>/5</li> <li><code>foldl_substring</code>/6</li> <li><code>foldl2_substring</code>/8</li> <li><code>foldl2_substring</code>/8</li> <li><code>foldr_substring</code>/5</li> <li><code>foldr_substring</code>/6</li> </ul></li> <li><p><code>base_digit_to_int</code>/3 and <code>det_base_digit_to_int</code>/2 now check for overflow and underflow in all bases, not only base 10.</p></li> <li><p>We have reduced the memory allocated by <code>to_lower</code> and <code>to_upper</code>.</p></li> <li><p><code>string_to_doc</code>/1 now escapes characters in its input argument with backslash escapes when required.</p></li> <li><p>Float special values, NaNs and Infinities, are now converted to strings in a way that is backend- and grade-independent. (Bug #348)</p></li> </ul> <h3 id="changes-to-the-store-module">Changes to the <code>store</code> module</h3> <ul> <li>Procedures in this module no longer acquire the global lock.</li> </ul> <h3 id="changes-to-the-term-module">Changes to the <code>term</code> module</h3> <ul> <li><p>The following predicate has been added:</p> <ul> <li><code>is_dummy_context</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-thread-module">Changes to the <code>thread</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>spawn_native</code>/4</li> <li><code>spawn</code>/4</li> <li><code>num_processors</code>/3</li> </ul></li> <li><p><code>spawn_native</code>/4 allows you to dedicate an OS thread to a Mercury thread.</p></li> <li><p><code>num_processors</code>/3 returns the number of processors available for parallel work.</p></li> </ul> <h3 id="changes-to-the-thread.mvar-module">Changes to the <code>thread.mvar</code> module</h3> <ul> <li><p>The following predicates and functions have been added:</p> <ul> <li><code>init</code>/1</li> <li><code>impure_init</code>/1</li> <li><code>try_read</code>/4</li> </ul></li> </ul> <h3 id="changes-to-the-thread.semaphore-module">Changes to the <code>thread.semaphore</code> module</h3> <ul> <li><p>The following predicate has been deprecated and will be removed in a future release:</p> <ul> <li><code>init</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-time-module">Changes to the <code>time</code> module</h3> <ul> <li><p>The following predicates have been added:</p> <ul> <li><code>localtime</code>/4</li> <li><code>mktime</code>/4</li> </ul></li> <li><p>The following functions have been deprecated and will be removed in a future release:</p> <ul> <li><code>localtime</code>/1</li> <li><code>mktime</code>/1</li> <li><code>ctime</code>/1</li> </ul></li> </ul> <h3 id="changes-to-the-tree234-module">Changes to the <code>tree234</code> module</h3> <ul> <li><p>The following predicate has been added:</p> <ul> <li><code>map_foldl4</code>/11</li> </ul></li> </ul> <h3 id="changes-to-the-version_array-module">Changes to the <code>version_array</code> module</h3> <ul> <li><p>The following function has been added:</p> <ul> <li><code>from_reverse_list</code>/1</li> </ul></li> </ul> <h2 id="changes-to-the-mercury-compiler">Changes to the Mercury compiler</h2> <ul> <li><p>We have extended tail call optimization from self recursive calls only to mutually recursive calls as well, when generating high level C code, C# code, or Java code. (The compiler has long been able apply tail call optimization to mutually recursive calls when generating low level C code.)</p></li> <li><p>We have added a new option <code>--warn-dead-preds</code>. While the existing option <code>--warn-dead-procs</code> asks the compiler to generate warnings for every unused procedure of the module being compiled, the new option asks the compiler to generate a warning for an unused procedure only if none of the procedures of a predicate or function is used.</p></li> <li><p>We have added a new option <code>--warn-implicit-stream-calls</code>, which asks the compiler to generate a warning for every call to a predicate p/n if there is also a predicate p/(n+1) which differs from p/n only in that it has additional argument at the front of its argument list that specifies an I/O stream. This is intended to generate warnings for calls to predicates such as <code>io.write_string</code>/3, which writes to the current output stream, to encourage programmers to call <code>io.write_string</code>/4 instead. If the option is given, the compiler will also generate warnings for calls to predicates such as <code>io.see</code>, <code>io.seen</code>, <code>io.tell</code> and <code>io.told</code>, which set the current input or output streams respectively.</p></li> <li><p>We have added a new option <code>--warn-non-contiguous-decls</code>, which asks the compiler to generate a warning if the mode declaration(s) of a predicate or function does not immediately follow its <code>:- pred</code> or <code>:- func</code> declaration. This is option is turned on by default.</p></li> <li><p>We have added the new options <code>--warn-inconsistent-pred-order-clauses</code> and <code>--warn-inconsistent-pred-order-foreign-procs</code>. Both of these ask the compiler to generate a warning if, among either (a) the set of exported predicates and functions of the module, or (b) the set of nonexported predicates and functions of the module, the order of their definitions does not match the order of their declarations. The first option applies only to predicates and functions defined by Mercury clauses; the second applies to predicates and functions defined by either Mercury clauses or foreign procedures.</p> <p>The option <code>--warn-inconsistent-pred-order</code> is a shorter synonym for <code>--warn-inconsistent-pred-order-clauses</code>.</p></li> <li><p>We have added a new option <code>--inhibit-style-warnings</code>, which tells the compiler not to generate any warnings that are purely about programming style, and do not point out code that is reasonably likely to be wrong.</p></li> <li><p>We have added a new option <code>--inline-linear-tail-rec-sccs</code> that tells the compiler, when it finds a set of procedures that each contain one tail call to one <em>other</em> member of the set, to inline the tail calls to turn those mutually recursive procedures into procedures that each contain only <em>self</em> tail recursion.</p></li> <li><p>We have significantly improved the compiler's ability to detect, and to generate warnings about, code that violates the occurs check.</p></li> <li><p>We have fixed a long-standing bug causing crashes in deep profiling grades, related to unify/compare for tuples. (Bug #3)</p></li> <li><p>We have fixed some bugs with constrained polymorphic modes.</p></li> <li>We have removed legacy support for the following systems: <ul> <li>IRIX</li> <li>OSF/1</li> </ul></li> <li><p>The <code>asm_fast*</code> and <code>reg*</code> grades now work on 64-bit Intel OS X systems when using GCC as the C compiler. See README.MacOS for further details.</p></li> <li>We have improved support for FreeBSD: <ul> <li>allow architectures other than i*86</li> <li>allow use of shared libraries</li> <li>enabled threads support</li> <li>enabled parallel job support with <code>mmc --make</code></li> </ul></li> <li><p>We have added support for OpenBSD.</p></li> <li><p>We have added support for Linux systems using musl libc.</p></li> <li><p>We have improved support for AIX.</p></li> <li><p>The compiler now reports an error for binary/octal/hexadecimal integer literals that cannot be represented in the compiler's native <code>int</code> type.</p></li> <li><p>Class files generated for executables in the Java grade are now automatically packaged up into Java archives (JARs).</p></li> <li><p>The <code>--generate-module-order</code> and <code>--imports-graph</code> options no longer imply <code>--generate-dependencies</code>.</p></li> <li><p>The compiler does not set the runtime search path when <code>--mercury-linkage=static</code> is used.</p></li> <li><p>We have added an option <code>--no-default-runtime-library-directory</code> to prevent the compiler adding any directories to the runtime search path automatically.</p></li> <li><p>We have renamed the <code>--inhibit-accumulator-warnings</code> option to <code>--no-warn-accumulator-swaps</code>.</p></li> <li><p>We have disabled intermodule optimisation of any predicates or functions using <code>try</code> goals. This fixes a serious issue as <code>try</code> goals are not properly written to <code>.opt</code> files, so when read back would not actually catch any exceptions.</p></li> <li><p>We have disabled the old <code>--num-reserved-objects</code> option.</p></li> <li><p>We have upgraded the bundled Boehm GC to v7.6.10 and libatomic_ops to v7.6.2.</p></li> </ul> <h2 id="changes-to-the-mercury-debugger">Changes to the Mercury debugger</h2> <ul> <li><p>Interactive queries are now supported on OS X.</p></li> <li><p>The <code>break</code> command can now auto-complete on the filename:linenumber pairs of events, provided the Mercury system can access the readline library.</p></li> <li>Interactive queries have been improved: <ul> <li>Queries can use variable bindings from the current environment.</li> <li>Exceptions thrown from queries are properly handled.</li> <li>Non-canonical output bindings are now printed in solutions.</li> <li>Underscore variables are no longer printed in solutions.</li> </ul></li> <li><p>We have added a <code>browse --web</code> command to view terms in a web browser.</p></li> </ul> <h2 id="changes-to-the-extras-distribution">Changes to the extras distribution</h2> <ul> <li>We have added support for Unicode and other enhancements to the <code>lex</code> and <code>regex</code> libraries. Thanks to Sebastian Godelet.</li> </ul> <p>For news about earlier versions, see the HISTORY file.</p> </body> </html>