ALF:
   ALF (Algebraic Logic Functional programming language) is a
   language which combines functional and logic programming techniques.
   The foundation of ALF is Horn clause logic with equality which
   consists of predicates and Horn clauses for logic programming, and
   functions and equations for functional programming.  The abstract
   machine is based on the Warren Abstract Machine (WAM) with several
   extensions to implement narrowing and rewriting.     In the current
   implementation programs of this abstract machine are executed by an
   emulator written in C. It is available by anonymous ftp from
      ftp://ftp.germany.eu.net/pub/programming/languages/LogicFunctional/
   (aka simpson.germany.eu.net) as the files alf_*.zoo
   (Documentation, C sources for the emulator, the preprocessor and the
   compiler). For further information, contact Rudolf Opalla
   <opalla@julien.informatik.uni-dortmund.de>.

CORAL:
   CORAL is a deductive database/logic programming system developed at
   the University of Wisconsin-Madison. It is a declarative language
   based on Horn-clause rules with extensions like SQL's group-by and
   aggregation operators, and uses a Prolog-like syntax.

   CORAL is available via anonymous ftp from ftp.cs.wisc.edu:/coral/.  The
   distribution includes source code compatible with AT&T C++ Version 2.0
   or later, executables for Decstations and SUN 4s, the CORAL User
   Manual, and some related papers containing a language overview and
   implementation details.  (A version of the source code compatible with
   GNU g++ will be available shortly.) For more information, contact
   Raghu Ramakrishnan, <raghu@ricotta.cs.wisc.edu>.

Lolli:
   Lolli is an interpreter for logic programming based on linear logic
   principles. Lolli, named for the linear logic implication operator
   "-o" called lollipop, is a full implementation of the language
   described in the paper "Logic Programming in a Fragment of
   Intuitionistic Linear Logic" (Josh Hodas & Dale Miller, to appear in
   Information and Computation), though it differs a bit in syntax, and
   has several built-in extra-logical predicates and operators. Lolli is
   available by anonymous ftp from 
      ftp://ftp.cis.upenn.edu/pub/Lolli/ 
   This distribution includes full ML source, along with a Makefile, as well
   as several background papers and a collection of example programs. For
   those who do not have SML-NJ at their site, the authors hope to
   provide pre-built binaries for a variety of architectures. These
   binaries can be found on 
      ftp://ftp.cis.upenn.edu/pub/Lolli/binaries/
   At present Sparc and NeXT binaries are available.  If you compile
   lolli on a new architecture, please contact Josh Hodas at
   <hodas@saul.cis.upenn.edu> so that he can make your binary available.

Mercury:
   Mercury is a new, purely declarative logic programming language.
   Like Prolog and other existing logic programming languages, it is a
   very high-level language that allows programmers to concentrate on the
   problem rather than the low-level details such as memory management. 
   Unlike Prolog, which is oriented towards exploratory programming,
   Mercury is designed for the construction of large, reliable, efficient
   software systems by teams of programmers.  As a consequence,
   programming in Mercury has a different flavor than programming in
   Prolog.

   The main features of Mercury are:

	-  Mercury is purely declarative: predicates in Mercury do not
	   have non-logical side effects.
	-  Mercury is a strongly typed language.  Mercury's type system is
	   based on many-sorted logic with parametric polymorphism, very
	   similar to the type systems of modern functional languages such
	   as ML and Haskell.  Type errors are reported at compile time.
	-  Mercury is a strongly moded language.  
	-  Mercury has a strong determinism system. 
	-  Mercury has a module system.  
	-  Mercury supports higher-order programming,
	   with closures, currying, and lambda expressions.
	-  Mercury is very efficient (in comparison with existing logic
	   programming languages).  Strong types, modes, and determinism
	   provide the compiler with the information it needs to generate
	   very efficient code.

   The current Mercury system runs on Unix machines. It is known to run on
   Solaris 2.x, IRIX 5.x, Ultrix 4.3, OSF/1.1, BSDI 1.1, and Linux. It
   should run without too many changes on other Unix variants as well.
   You need gcc version 2.6.3 or higher and GNU make version 3.69
   or higher.  The Mercury distribution is available via anonymous
   ftp or WWW from the following locations:

	   Australia:      ftp://turiel.cs.mu.oz.au/pub/mercury
			   http://www.cs.mu.oz.au/~fjh/mercury
	   USA:            ftp://ftp.cs.sunysb.edu/pub/XSB/mercury
	   Europe:         ftp://ftp.csd.uu.se/pub/Mercury

   The Mercury WWW page is http://www.cs.mu.oz.au/~zs/mercury.html

See also LIFE, SLG, and XSB in [2-1], BeBOP in [2-3], and Oz in [2-5].