Curry: A Truly Functional Logic Language
(ILPS'95 Workshop on Vision for the Future of Logic Programming)
This paper sketches the very first ideas of the possible features of Curry.
It is outdated and only included to track the history of Curry.

KiCS2: A New Compiler from Curry to Haskell
(WFLP 2011)
This paper describes Curry implementation KiCS2 which is based on
the translation of Curry programs into Haskell programs.
This implementation supports various search strategies.
The benchmarks show that it can compete with or outperform other existing implementations of Curry.

An Implementation of Narrowing Strategies
(PPDP 2001)
This paper describes an implementation of the kernel of Curry
by translating functional logic programs into
imperative (Java) programs without an intermediate abstract machine.
A central idea of this approach is the explicit representation
and processing of narrowing computations as data objects.

An Efficient Abstract Machine for Curry
(ATPS'99)
This paper describes an abstract machine for the implementation of Curry.
The abstract machine is an extension of a stack-based graph reduction
machine and is implemented in C.

Program Transformation

From Boolean Equalities to Constraints
(LOPSTR 2015)
This paper describes an automatic method to transform Boolean equalities
into constraint equalities, if possible. With this transformation tool,
it is sufficient to use only Boolean equalities in Curry programs,
since operationally more efficient constraints are automatically inserted.

A Practical Partial Evaluator for a Multi-Paradigm Declarative Language
(FLOPS 2001)
This paper describes an approach to the partial evaluation
of arbitrary Curry programs. In particular, it addresses the partial
evaluation of all standard features like external functions,
higher-order functions, concurrency etc.
The partial evaluator based on these ideas
is implemented in Curry itself and is available
here.

Applications

A Typeful Integration of SQL into Curry
(WFLP 2016)
This paper describes the integration of SQL queries in Curry programs
in a type-safe manner, based on a logical description of the relational database
as an entity-relationship (ER) model.

An ER-based Framework for Declarative Web Programming
(TPLP 2014)
This paper describes a framework to generate web applications from an
entity-relationship (ER) model of the underlying data. The generated
implementation contains operations to create and manipulate entities
of the data model, supports authentication, authorization, session
handling, and the composition of individual operations to user
processes. Furthermore, the implementation ensures the integrity of
the database after update operations.

Declarative Programming of User Interfaces
(PADL 2009)
This paper shows how the features of Curry can be exploited to define
user interfaces in a declarative manner so that graphical user interfaces for desktop applications
as well as web user interfaces can be obtained from the same user interface specification.

High-Level Server Side Web Scripting in Curry
(PADL 2001)
This paper describes the design of a library for programming dynamic weg pages
in Curry based on standard CGI features.
Due to the use of the functional and logic features of Curry,
details and frequent errors in standard CGI programming are avoided
by an abstraction layer which also supports event handlers, state variables
and interaction sequences.

A Functional Logic Perspective on Parsing
(in Springer LNCS 1722)
This paper describes the design of a library for building
parsers where the functional and logic features are exploited.
This library is available in the
PAKCS distribution of Curry.

Extensions

Default Rules for Curry
(TPLP 2017)
This paper proposes a new concept of default rules for Curry that simplifies
some computation tasks and is conform with the core properties of Curry.
Default rules are integrated with a preprocessor in the Curry implementations
PAKCS and
KiCS2.

Eliminating Irrelevant Non-determinism in Functional Logic Programs
(PADL 2017)
This paper proposes determinism annoations for operations defined in Curry.
A determinism annotation avoids the recomputation of identical results
and, thus, improve the operational behavior of Curry programs without
destroying its completeness.
Determinism annotations are integrated with a preprocessor in the Curry implementations
PAKCS and
KiCS2.

Set Functions for Functional Logic Programming
(PPDP 2009)
This paper proposes set functions as a new feature to encapsulate
nondeterministic computations in Curry.
In contrast to previous approaches, the result of set functions
is independent of their evaluation order. Thus, they can be considered
as a declarative approach to encapsulate search.

Adding Constraint Handling Rules to Curry
(WLP 2006)
This paper proposes an integration of Constraint Handling Rules (CHR),
a rule-based language to specify application-oriented constraint
solvers, into Curry.
This integration provides a convenient way to specify and use flexible
constraint systems in applications implemented in Curry.
A prototypical implementation is available
here.

Declarative Programming with Function Patterns
(LOPSTR 2005)
This paper proposes an extension of Curry that allows the
definition of operations with patterns containing other defined
operation symbols. Such “function patterns” allow a direct representation
of specifications as declarative programs, provide better abstractions
of patterns as first-class objects, and support the high-level
programming of queries and transformation of complex structures.

An Object-Oriented Extension of the Declarative Multi-Paradigm Language Curry
(IFL 2000)
This paper describes ObjectCurry, an extension of Curry to support a classical
object-oriented programming style. ObjectCurry supports the definition
of templates and the dynamic creation of objects, i.e., instances of templates.
Objects owns a state and react when they receive a message.
Template definitions can be reused by inheritance. Although
ObjectCurry has a specific type system that combines parametric
polymorphism with subtype polymorphism, each ObjectCurry program
can be translated into a standard Curry program so that
ObjectCurry can be implemented as a preprocessor for a standard
Curry system.