mercury/extras

This directory contains various additional libraries, tools,
and so forth that are not part of the Mercury standard library.

Most of these can be built by running the commands `mmake depend' and
then `mmake' in the relevant subdirectory, and many can be installed by
running `mmake install'.

cgi		A couple of Mercury library modules for doing HTML forms
		programming using CGI (Common Gateway Interface).

clpr		A Mercury interface to the CLP(R) constraint solver,
		for solving arithmetic constraints on (floating point)
		real numbers.

complex_numbers
		A Mercury library package containing support for
		complex and imaginary numbers.

concurrency	Support for coroutining and concurrent execution of
		deterministic (or cc_multi) goals, and some data structures
		for communicating between different concurrent threads.

curs		A Mercury library providing a somewhat more complete
		and more faithful binding to the curses and panel
		libraries (the latter is used to provide elementary
		windowing facilities, rather than doing so in Mercury).

curses		A Mercury library providing a (partial) binding to 
		curses; a package that provides methods for manipulating
		the text screen (creating windows, placing characters, etc).

dynamic_linking
		An interface to the C functions dlopen(), dlsym(), etc.
		that are supported by most modern Unix systems.

graphics	A couple of packages for doing graphics programming
		and GUIs in Mercury: a Mercury interface to tcl/tk
		and a Mercury binding to OpenGL.

lazy_evaluation
		A library module `lazy' containing support for optional
		lazy evaluation in Mercury, together with some examples
		of its use, including a module `lazy_list' that defines
		a lazy list data type.

lex		A lexer package for Mercury that works over io__states,
		strings, and so forth.  It comes with a rich set of
		standard regular expressions and the user is free to add
		their own.                                                      

moose		A parser generator for Mercury.  Moose works much like
		yacc or bison, it takes a grammar and generates a table
		driven LALR parser for it.  You can add code to the
		grammar to handle synthesized or inherited attributes.
		Currently you need to write your own lexer to interface
		to moose.

morphine	A trace analysis system for Mercury.

odbc		A Mercury interface to ODBC (Open Database Connectivity),
		for interfacing to standard relational database packages.

posix		A Mercury interface to some of the POSIX
		(Portable Operating System Interface) APIs.

quickcheck	An autotesting tool similar to Haskell's QuickCheck.

references	A library package containing modules for manipulating
		ML-style references (mutable state).

stream		Generic IO interface using typeclasses.

trailed_update	Some library modules that make use of backtrackable
		destructive update, including a module which provides
		some support for Prolog-style unification constraints.

xml		An XML parsing library.