Archived
News
  2007-03  
  29:

I have eliminated my "corrections" to the Mercury extras xml library (I had an outdated version of the library as outlined in the 2007-03-18 news post, so my corrections were redundant the the Mercury team's). At the same time, I have moved my XML enhancements into the utils library and promoted the doug_graph module from alpha; it is now also included in utils.

  18:

A new library and several improvements can be found in the shared repository:

  • The xml library provided in the Mercury extras distribution is out-of-date; it no longer compiles. I have fixed the compile errors and added several modules (to assist in XML transformations and pretty-printing) and tests.

    Update 2007-03-28:

    I was in error in the above item: my copy of the xml library provided by the Mercury team was out of date; the version supplied with the extras distribution by the Mercury team is working correctly.

    This means my fixes to the xml library are redundant, so I withdraw them. The extended functionality, however, I do continue to find (very) useful, so I am moving these enhancements as an xml library under the utils umbrella.

  • Several improvements are available for qcheck2:

    1. I have modified the qcheck2 library so that it now uses the RNG protocol as proposed in the Mercury users' maillist. I have also modified the reporting feature to accept a polymorphic type for module.predicate unit tests ... this improvement 'upgrades' qcheck2 to be an independent library (qcheck was also an independent library).

    2. The program qcpt that generates the module.predicate test points for a system has also been updated to use the new qcheck2 reporting protocol. qcpt is bundled with ltq.

  • I have entirely changed the utils library:

    1. Although useful for a small number of repetitions, the peano module becomes unweildly for large cycles (1,000,000 is represented as 1,000,001 cons cells!). So, I have discarded it in favor of a slightly more sophisticated counting algorithm (where 1,000,000 is represented by 7 cons cells) in the utils.series module that now also includes loop abstraction with func unfold/3 and pred svunfold/6 (the latter being used when one must also update a dependent state variable).

    2. Julian Fondrant on the Mercury Users maillist proposed a RNG typeclass and protocol, and published a module implementation using the tausworthe3 algorithm. I have incorporated this module (as utils.random) with a simplified façade and other minor corrections.

  2007-02  
  14:

  • The dynamic syntax compiler ltq ("Logical Types Quicksilver") and qcpt (the QuickCheck type generator) have been modified to work with the new structure of Melbourn's Mercury ops module. The new system has been updated and is available in our shared repository.

  • The qcheck2 library has been updated to work with the current ltq; it includes two sample modules with different reportage options. It can be found in the shared repository.

  • The peano module has received some new counting functions to simplify the user's task of constructing small peano numbers.

  02:

We present a very tiny foreign interface to libtiff. The module tiffany allows reading and writing simple RGBA TIFFs with two-dimensional arrays. As the matrix module matures, we will use that protocol for more comprehensive image filtering. This interface is presented with some samples and (currently) no documentation (other than code comments) as is available from our shared repository. Both libtiff and the matrix protocol must be available to run the samples.

Update 2007-02-06:

Per the suggestions of the Mercury team, I have updated the foreign protocol calls from the old C-specific interface to the generic and supported interface. Also, made the library "more" threadsafe by eliminating the global file pointers and subsuming those values into the image structure.

Update 2007-02-07:

Changing the c_pointer type to a foreign_type pragma (again) to avoid the old C-style foreign interface and also to eliminate unnecessary warnings about int-to-pointer casts.
  2007-01  
  31:

As the Mercury standard library does not have a matrix protocol, I am building a module that handles some basic matrix operations; this module and its test suites will be added to the utils library when in serviceable condition.
  30:

Thanks to the efforts of the Mercury research group at Melbourne, their Mercury compiler (mmc) is now available for Macintosh computers with the Intel chipset. This is the alpha ROTD (2007-01-21) as opposed to the currently sanctioned 0.13.1 release, so some things are experimental in this version of the compiler. Email logicaltypes.com if you wish to have a binary distribution.

Our compiler, ltq (that allows syntactic extensions with the op/3 directive, see the news archives at 2006-03-02), may need some work as the Mercury research team has changed the ops module. This, of course, also means that systems that depend on these improvements, such as the test-building framework qcpt (see news archive post 2006-05-12), must also be retested. We will post an update when qld is again tested and working.

  2006-07  
  17:

The various data structures provided in the ROTD extras/ distribution that handles solver types (particularly the various any modes) do not compile because of purity issues; also, since their release, the coding style has changed for module qualification. The fixes to get these types compiled are here. For the Mercury team's review are the diffs to fold back into the distribution.

  2006-05  
  13:

We present a complete rewrite of Mercury's QuickCheck implementation: qcheck2 (the sample unit test module (peano_unit_tests) requires the peano module in order to run). The essence of testing à la qcheck -- type discernment to obtain (random) test values with a test specification language -- remains unchanged. The new features of this new version enhance the system with:

  1. complete control over what is reported and when it is reported;
  2. dynamic control over ranges of random number-like values (ints, floats and chars) as well as the random number generator type itself;
  3. and for the code-hacker: qcheck2 is broken up into separate modules along functional lines

The documentation for qcheck (upon which qcheck2 is built) is a model for any system to follow; so, documentation, to include a system description and transition guide, for qcheck2 is under development.

Update 2006-05-20:

As the test description (Description) may now be of any type -- even non-comparable types, such as, for example, function types -- using a map with Description keys is will cause errors when using Description types that cannot be compared. As such, the qstate now uses an assoc_list to accumulate the test results.

Update 2006-05-21:

Added information to the summary report: this report now shows which predicates were not tested. The work-in-progress documentation now covers the reporting facility comprehensively.
  12:

ltq (Logical Types Quicksilver compiler) now comes with qcpt (QuickCheck Predicate Types), a system that discerns the interface predicates and functions of a system (to facilitate comprehensive unit testing). Perhaps even more important is the inclusion of a README that doubles as a HOWTO and INSTALL document.
  11:

Completed the document describing an implementation of mutable syntax for Mercury. This article in available in the literature section (see above).
  2006-04  
  30:

The graph module takes a rather non-directed approach to locating a path from Node1 to NodeN. This is fine if the path has no associated cost, but if one is looking for the best path (where a path has an associated cost), this laissez-faire approach becomes problematic.

As I often need a efficient path in a graph, I have added best_path/5 and other supporting predicates that cannot be implemented well operationally given the protocol of module graph and submitted these changes to the Mercury team for review. While they consider these changes, I provide the implementation here as module doug_graph, with an associated example. Locating the best path in the given example using the naive path implementation took over 20 seconds; the reimplementation here completes the computations in less than a second.
  27:

The following Mercury compiler distributions are available from here on request:

  • mercury-2006-04-26-rotd-powerpc.apple.darwin8.5
  • mercury-2006-04-26-rotd-sparc.sun.solaris2.8

These distributions include the extras/, the samples/ (in extras/) and the HTML documentation (in doc/).
  2006-03  
 
29873210165432108:

The Mercury development team has fixed the problem with nesting of disjunctive terms when output with term_io.write_term/4 with ROTD-2006-03-07 compiler distribution. It, along with the op/3 declaration enhancement (ltq), are available from us. Send an email (see contact information below) if you wish to obtain one of the following distributions:

  • mercury-2006-03-25101854310789-rotd-powerpc.apple.darwin8.35
  • mercury-2006-03-287210185431079-rotd-sparc.sun.solaris2.8

These distributions include the extras/, the samples/ (in extras/) and the HTML documentation (in doc/).
0346:

term_io.write_term/4 does not properly handle disjunctions. I've submitted a patch to the Mercury development team, but in the interim, I've included the change in distributions (as dopp relies on write_term/4 to output the op/3-free code results). Also, compiler/prog_io.m has quite a few disjunctions handling (now dead) declaration types, I've submitted this patch to the Mercury team, but have also patched local distributions. The most recent distributions available are:

  • mercury-2006-03-01-rotd-fixed-write_term-sparc.sun.solaris2.8
  • mercury-2006-03-0134-rotd-fixed-write_term-powerpc.apple.darwin8.3

Both these distributions have ltq included. Email me if you wish a copy of one of the above distributions or of the stable release (0.12.2) on either architecture.

Update 2006-03-08:
The Mercury team has corrected the compiler so that terms are appropriately parenthesized. This eliminates the need for my term_io.write_term/4 hack, so future releases of the distributions from this site will revert to straight-up Mercury. Enhancements, such as op/3 declarations, will be included in extras/ (the source code) and in bin/.
02:

There is quite a debate going on at the developers discussion forum as to the merits, extent and implementation of the op/3 declaration. Up to this point, we have patched the Mercury compiler distribution so that it accepts and processes op/3 declarations. This has proved to be rather onerous as new distributions have been coming out regularly. Instead, prompted by the Mercury team, I have developed an op/3 preprocessing system. ltq <Executable> ("Logical Types Quicksilver") creates build/Makefile, then executes the Makefile which calls dopp <Dependencies> ("Dynamic Op PreProcessor") which translates op/3-enhanced files into plain vanilla Mercury ones. The Makefile then builds the executable with the 'mmc --make --infer-all <Executable>' command. This build system is locally available from this site, and also included in Mercury distributions that we produce from this month onward.

Update 2006-03-10:
I have updated ltq so that it takes any number of arbitrary command-line arguments (these preceed the <Executable> argument). These arguments are passed, unmolested, to mmc.
Update 2006-03-13:
Currently, we are fully integrating op/3 declarations into working products. In building auxilary libraries we have found that we need to mirror mmc's library-building indicator (prepending 'lib' to the target module's name). Adding this functionality required a modification to ltq's build process. This change is reflected in build system offered here. We leave the library installation process to mmc; that is, noddingly: in the generated Makefile, there is an command that passes the proper arguments to mmc with a make install command.
Update 2006-03-24:
The library building and installation process differed slightly in ltq. Eliminated that difference and published a new version of this system.
Update 2006-03-29:
ltq now automatically creates the build/ directory (the repository of build products, including the files converted from op/3-enhanced sources to canonically represented sources). This eliminates errors in ltq's build process when it cannot find the nonexistent directory. The new distribution is available, as always, here.
  2006-02  
 
17: The bleeding-edge releases of the Mercury compiler (the ROTD (release of the day) 2006-02-11), both for standard Mercury and the Quicksilver enhancements from Logical Types (op/3 declarations and binary-trees and -sets with externalizable structure) are compiled and available for Mac OSX.4 systems. These releases are alpha quality, but do contain several interesting developments, such as improved constraint logic programming syntax, injections (bi-directional maps) and improved term-as-XML handling. Please email if you wish to obtain a copy (see contact information).
Update 2006-02-19:
The Quicksilver distribution has been updated to the ROTD-2006-02-1618.
Update 2006-02-268:

There are a new set of distributions available:

  • ROTD-2006-02-235 distribution now available for sparc.sun.solaris2.8
  • ROTD-2006-02-23 distribution for powerpc.apple.darwin8.3
  • Quicksilver ROTD-2006-02-25 distribution for powerpc.apple.darwin8.3 and for the sparc.sun.solaris2.8 as well
  2006-01  
 
31: Quicksilver version 0.12.2 for Mac OS-X.4 is available along with installation instructions.
 

Update (2006-03-04):

I have removed all distributions from this repository. Please email me if you wish to obtain a copy of any distribution mentioned here.
31: Quicksilver version 0.12.2 for Solaris 8 is available along with installation instructions.
31: Logical Types, LLC is no longer producing binary distributions of Mercury that do not support op/3 declarations. Quicksilver (Mercury with op/3 support) is a strict superset of Mercury and what Logical Types produces.
16: I've posted a review of the PADL-2006.
06: Here is a module that prints out a parsed term in its canonical form (write_canonical.m; useful for inspecting terms with op/3 syntax) and a test module (test_op.m) that exercises write_canonical. This can be used with the regular Mercury compiler, but is designed for Quicksilver compiling modules with embedded op/3 declarations.
04: Mercury compiler enhanced with op/3 declarations for both PowerPC architecture Mac OS-X.4 systems (with installation instructions) and Sparc architecture Solaris 8 systems (with its own installation instructions) available for download. The compiler executable is named "lqc" for "Logical Types Quicksilver Compiler". A supporting document, detailing the changes to the compiler to permit users to insert op/3 declarations (followed eventually by the typed operators in context) into module implementations, will follow in short order.
 

Update (2006-01-31):

These distributions (and the ones mentioned below) are obsolete. Email me for the current stable release.
  2005-12  
 
27: Mercury compiler for Sparc architecture Solaris 2.8 systems available for download. See the installation instructions to get Mercury running on your SPARC.
24: Mercury compiler for PowerPC architecture Mac OS-X.4 systems available for download. See the installation instructions to get Mercury running on your Mac.

Copyright © 2006, 2007, Logical Types, LLC. All rights reserved.