Note: this is only a selection and, thus, always incomplete!

Functional Logic Programming: From Theory to Curry
(*Programming Logics - Essays in Memory of Harald Ganzinger*)

This papers surveys general features of functional logic languages,
and discusses the design, implementation, extensions, and applications of Curry.

Functional Logic Programming
(*CACM 2010*)

This article reviews the main ideas of functional logic programming and Curry.

Programming with Narrowing: a Tutorial
(*JSC 2010*)

This paper surveys the use of narrowing, i.e., the operational principle of Curry,
from a programmer viewpoint by means of examples.

Multi-paradigm Declarative Languages
(*ICLP 2007*)

This papers surveys general features of functional logic languages
and discusses the design of Curry.

Evaluation Strategies for Functional Logic Programming
(*JSC 2005*)

This paper contains a survey on evaluation strategies and classes of functional logic
programs.

The Integration of Functions into Logic Programming: From Theory to Practice
(*JLP 1994*)

This papers surveys the early developments in the operational principles and implementations
of integrated functional logic languages.

Free Theorems for Functional Logic Programs
(*PLPV 2010*)

An example driven investigation of the restrictions of free theorems in Curry.

Overlapping Rules and Logic Variables in Functional Logic Programs
(*ICLP 2006*)

This papers shows the equivalence of logic variables and
nondeterministic operations in functional logic programs so that a
kernel language need only to implement one of these features. This
result is the basis of the KiCS implementation of Curry.

Operational Semantics for Declarative Multi-Paradigm Languages
(*JSC 2005*)

This paper describes an operational semantics covering most aspects
of Curry, like laziness, sharing, concurrency, non-determinism etc.

Controlling Search in Declarative Programs
(*PLILP/ALP'98*)

This paper describes the idea and the use of the encapsulated
search features of Curry.

Optimal Non-Deterministic Functional Logic Computations
(*ALP'97*)

This paper motivates the use of non-deterministic functions
in Curry and proposes an optimal evaluation strategy.

A Unified Computation Model for Functional and Logic Programming
(*POPL'97*)

This paper contains the first
detailed description of the operational model of Curry.

A Unified Computation Model for Declarative Programming
(*APPIA-GULP-PRODE'97*)

This paper contains an updated and slightly modified introduction
into the computation model of Curry.

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.

A New Functional-Logic Compiler for Curry: Sprite
(*LOPSTR 2016*)

This paper describes a new native code compiler for Curry which implements a fair evaluation
of non-deterministic branches in a computation.

Implementing Equational Constraints in a Functional Language
(*PADL 2013*)

This paper describes the implementation of equational constraints
and functional patterns in KiCS2.

Search Strategies for Functional Logic Programming
(*ATPS 2012*)

This paper describes the features of KiCS2 for encapsulated search
and the implementation of various search strategies
and compares their efficiency by some benchmarks.

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.

Compiling Multi-Paradigm Declarative Programs into Prolog
(*FroCoS 2000*)

This paper describes a method to compile Curry programs into
Prolog programs. This compiler is the central part of the
PAKCS programming environment for Curry.

An Abstract Machine for Curry and its Concurrent Implementation in Java
(*Journal of Functional and Logic Programming*, 1999)

This paper describes an implementation of Curry in Java where
the concurrent and non-deterministic features of Curry
are implemented with Java threads.

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.

Implementing Encapsulated Search for a Lazy Functional Logic Language
(*FLOPS'99*)

This paper describes an abstract machine for the implementation of Curry
and its features for encapsulating search. This is the basis
of a Curry implementation which can be found
here.

UPV-Curry: An Incremental Curry Interpreter
(*SOFSEM'99*)

This paper describes the ideas of the Curry interpreter developed
at the Technical University of Valencia.
An implementation is available
here.

Incremental Needed Narrowing
(*IDL'99*)

This paper contains the correctness proof of the incremental
narrowing algorithm described in the previous paper.

CurryCheck: Checking Properties of Curry Programs
(*LOPSTR 2016*)

This paper the tool CurryCheck to test properties contained
in Curry programs.

Lazy and Faithful Assertions for Functional Logic Programs
(*WFLP 2010*)

This paper proposes a new form of assertions that can be used
in Curry programs.

EasyCheck — Test Data for Free
(*FLOPS 2008*)

A QuickCheck-like testing tool that employs narrowing to generate test cases.

- [2007, inproceedings]
- Fischer, S., & Kuchen, H. (2007).
*Systematic generation of glass-box test cases for functional logic programs*. Paper presented at the PPDP '07: Proceedings of the 9th ACM SIGPLAN international symposium on Principles and practice of declarative programming, New York, NY, USA.

Reporting Failures in Functional Logic Computations
(*ENTCS 177*)

This paper describes the implementation of failure reporting
in the Curry implementation
PAKCS.

Observing Functional Logic Computations
(*PADL 2004*)

This paper describes the tool COOSy to observe the results of
computations in a Curry program. COOSy is integrated in the Curry
implementation
PAKCS.

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.

Using an Abstract Representation to Specialize Functional Logic Programs
(*LPAR'2000*)

This paper describes a new approach to the partial evaluation
of Curry programs. The partial evaluator based on these ideas
is implemented in Curry itself and is available
here.

Improving Functional Logic Programs by Difference-Lists
(*ASIAN 2000*)

This paper describes an approach to optimize Curry programs
by a stepwise transformation based on difference lists
as used in logic programming.

Specialization of Inductively Sequential Functional Logic Programs
(*ICFP'99*)

This paper describes a partial evaluator for the narrowing-based
subset of Curry and discuss its advantages w.r.t. lazy narrowing
strategies.

A Partial Evaluation Framework for Curry Programs
(*LPAR'99*)

This paper describes a partial evaluator for a subset of Curry.
An implementation is available
here.

A Modular and Generic Analysis Server System for Functional Logic Programs
(*PEPM 2014*)

This paper presents the ideas and implementation of the
program analysis framework CASS
which is part of the
PAKCS and
KiCS2 distributions.

Call Pattern Analysis for Functional Logic Programs
(*PPDP 2008*)

This paper presents a new program analysis framework to approximate
call patterns and their results in functional logic programs.

CurryBrowser: A Generic Analysis Environment for Curry Programs
(*WLPE 2006*)

This paper presents the ideas of CurryBrowser,
a generic analysis environment for Curry programs that is integrated into the
PAKCS environment.

Nondeterminism Analysis of Functional Logic Programs
(*ICLP 2005*)

This paper presents a method to analyse the non-determinism
behavior of Curry programs based on a type inferences for nonstandard types.

Type-based Nondeterminism Checking in Functional Logic Programs
(*PPDP 2000*)

This paper describes a method to analyse the non-determinism
behavior of Curry programs.

A Generic Analysis Environment for Declarative Programs
(*WCFLP 2005*)

This paper presents CurryBrowser, a generic analysis environment for Curry programs.

CurryDoc: A Documentation Tool for Declarative Programs
(*WFLP 2002*)

This paper presents CurryDoc, a tool for the automatic generation
of documentation manuals in HTML format from Curry programs.

An Integrated Development Environment for Declarative Multi-Paradigm Programming
(*WLPE 2001*)

This paper describes CIDER, a graphical programming and
development environment for Curry and other declarative programming
languages. CIDER is intended as a platform to integrate various
tools for analyzing and debugging Curry programs.

A Graphical Development Environment for Functional Logic Languages
(*WFLP 2000*)

This paper describes IDE, an integrated development environment
for the functional logic languages Curry and Toy.

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.

Putting Declarative Programming into the Web: Translating Curry to JavaScript
(*PPDP 2007*)

This paper presents a technique to compile Curry programs into JavaScript programs
in order to check specific input conditions in the web browser, where the
programmer can implement these conditions in Curry.
The compiler is integrated as in the
PAKCS programming environment.

Type-Oriented Construction of Web User Interfaces
(*PPDP 2006*)

This paper proposes a new technique for the high-level construction of type-safe
web-oriented user interfaces in Curry. It is integrated as a library
( WUI) in the
PAKCS programming environment.

Functional Logic Design Patterns
(*FLOPS 2002*)

This paper introduces a handful of software design patterns that
are useful for programming in Curry.

Programming Autonomous Robots in Curry
(*WFLP 2002*)

This paper resent a framework to program autonomous robots in Curry.

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 Programming Approach to Graphical User Interfaces
(*PADL 2000*)

This paper describes the design of a library for GUI programming
in Curry. The functional features are exploited to define the
layout and to define new graphical abstractions, and the logic
features are used to specify the logical dependencies of an
interface.

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.

Demand-driven Search in Functional Logic Programs

This paper shows the advantages of Curry to implement
demand-driven search strategies. Moreover, it demonstrates
these advantages by an application from the area of music composition.

Teaching Functional and Logic Programming with a Single Computation Model
(*PLILP'97*)

This paper describes how to use Curry to teach functional and logic
programming paradigms in a single course based on Curry's computation
model.

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.

CHR(Curry): Interpretation and Compilation of Constraint Handling Rules in Curry
(*PADL 2015*)

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.
The implementation is available as a library in
PAKCS.

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.

Adding Linear Constraints over Real Numbers to Curry
(*FLPOPS 2001*)

This paper describes an approach to extend Curry by the possibility
to specify linear constraints over real numbers in Curry
that are processed by a specific constraint solving algorithm.

Distributed Programming in a Multi-Paradigm Declarative Language
(*PPDP'99*)

This paper describes an extension of Curry to support distributed
applications where a dynamically changing number of different program
units must be coordinated.