Table of Contents

Implementations of Curry

Since the development of Curry is an international initiative by various research groups,
several implementations are available and/or under development. Some of them are listed below.

PAKCS

The Portland Aachen Kiel Curry System (PAKCS)
is an implementation of Curry jointly developed by the
Portland State University,
the Aachen University of Technology, and the
University of Kiel.
PAKCS is an interactive system
to develop Curry programs. It has a simple user interface,
some interactive debugging features and various useful tools.
Moreover, it also contains
constraint solvers for arithmetic, Boolean, and finite domain constraints,
an implementation of ports for concurrent
and distributed applications (which is described
here),
libraries for implementing graphical user interfaces
(described here
or here),
libraries for programming dynamic web pages in a high-level manner
(described here
or here),
among other libraries for application programming
(e.g., XML processing, meta-programming, sets, system access).
PAKCS compiles Curry programs into Prolog programs
(it has also other back ends, like
a compiler from Curry into Java or
a simple interpreter implemented in Prolog ,
but these are no longer maintained).

PAKCS (release 1.14.2) is also available as an Ubuntu 17.04 package.
If you run this OS, PAKCS can be installed with the command

MCC

The Münster Curry Compiler (MCC)
is a mature native code compiler for
Curry which conforms to the Curry report except for committed
choice which is not supported. Since release 0.9.5 there are no
longer any restrictions to the encapsulated search. Supported
extension to the Curry language include disequality constraints,
recursive pattern bindings, and IO exceptions. A distinctive
feature of the Münster Curry compiler is the integration of a
declarative debugger of wrong answers. An interactive Curry
environment and a make-like build tool for Curry are included
in the distribution. Besides the Gnu C compiler no other
software is needed to compile and run Curry programs with
the Münster Curry compiler.
Papers describing this implementation can be found
here .

KiCS2

The KiCS2
is a new implementation that translates Curry
into Haskell.
KiCS2 supports several search strategies to encapsulate search
(e.g., depth-first, breadth-first) and advanced extensions
of Curry like
encapsulated search via set functions
and functional patterns.
It also provides almost all libraries
of PAKCS for application programming so that it has been
used for various applications.

FLVM

The FLVM
is a virtual machine for functional logic computations.
Curry programs are compiled into FLVM instructions
that are executed by the FLVM interpreter that is implemented in Java.
A feature of the
FLVM is the implementation of a fair (i.e., operationally complete)
execution of nondeterministic computations and sharing
of deterministic computations over nondeterministic branches.

Sloth

The Sloth system
is a compiler which translates Curry programs
into Prolog programs. It is under development at the
Technical University of Madrid .
The Sloth system has an interactive interface
to load programs, evaluate expressions etc.

Zinc

The Zinc Compiler
is an experimental compiler for an
extended version of Curry and based on the
Münster Curry Compiler (MCC).
Type classes are the most notably extension at the moment.
The Zinc project is being developed at the
University of Oviedo
by Diego Berrueta.

Contact:
Diego Berrueta (diego AT berrueta DOT net)

Older Implementations

Below are some older implementations of Curry that are no longer
actively maintained.

KiCS

The Kiel Curry System (KiCS)
is a compiler that translates Curry
into Haskell.
KiCS provides several strategies to encapsulate search
(e.g., depth-first, breadth-first).
It also contains an advanced debugging system
based on representing the execution of a Curry program
in a programmer-friendly call-by-value manner.

Curry2Java

Curry2Java
is another back-end for
PAKCS which translates
Curry programs into Java programs. It uses
Java threads to implement the concurrent and non-deterministic
features of Curry.
A paper describing this implementation can be found
here.

Narrowminder

Narrowminder
is an implementation environment (back end)
for functional logic programming and related languages.
It can compile Curry programs into Java code and implements
a complete and efficient implementation of needed narrowing
(breadth-first search). It can be also used as a back end
for related languages since it is based on a language-independent
intermediate XML representation of
FlatCurry programs.

TasteCurry

The TasteCurry interpreter
is a slow but fairly complete implementation
of Curry. It is an interpreter written in Prolog and does not implement
sharing. Thus, it is only intended to test smaller Curry programs.

UPV-Curry

UPV-Curry
is a Curry interpreter developed by the
ELP
group at the Technical University of Valencia
( UPV ).
It is implemented in Prolog and has an interactive interface
to load programs, evaluate expressions etc.
There exists also a larger application implemented with this
interpreter which simulates the ecological behavior of the Segura
river's basin.

CIDER

CIDER
is a graphical programming and development environment for Curry.
CIDER is intended as a platform to integrate various
tools for analyzing and debugging Curry programs.
CIDER is completely implemented in Curry. Although the graphical debugger
contains an interpreter for executing Curry programs,
it is only intended for visualizing the execution of smaller programs
and not for executing large programs.