A Selection of Papers related to Curry

Language features:

• Curry: An Integrated Functional Logic Language
  Here you can find a (draft) report describing Curry.
• 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.
• 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.
• Controlling Search in Declarative Programs (PLILP/ALP'98)
  This paper describes the idea and the use of the encapsulated search features of Curry.
• An Operational Semantics for Declarative Multi-Paradigm Languages (WFLP 2002)
  This paper describes an operational semantics covering most aspects of Curry, like laziness, sharing, concurrency, non-determinism etc.

Applications:

• 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.
• 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.
• 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.
• 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.
• 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.
• Programming Autonomous Robots in Curry (WFLP 2002)
  This paper resent a framework to program autonomous robots in Curry.
• Functional Logic Design Patterns (FLOPS 2002)
  This paper introduces a handful of software design patterns that are useful for programming in Curry.

Implementations:

• 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.
• 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.
• 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.
• 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 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.

Program Transformation:

• 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.
• 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 (ASSIAN 2000)
  This paper describes an approach to optimize Curry programs by a stepwise transformation based on difference lists as used in logic programming.
• 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.

Analysis:

• Type-based Nondeterminism Checking in Functional Logic Programs (PPDP'2000)
  This paper describes a method to analyse the non-determinism behavior of Curry programs.

Programming Environments:

• 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.
• 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.
• 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.
• A Generic Analysis Environment for Declarative Programs (WCFLP 2005)
  This paper presents CurryBrowser, a generic analysis environment for Curry programs.

Extensions:

• 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.
• 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 (WFLP 2000)
  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.
• 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.
• 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.