- Language Features and Semantics
- Program Transformation
- Programming Environments
Note: this is only a selection of the numerous papers related to Curry and, thus, always incomplete! If you have some paper to add, please write to us (see imprint).
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.
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.
Functional Logic Programming (CACM 2010)
This article reviews the main ideas of functional logic programming and Curry.
Multi-paradigm Declarative Languages (ICLP 2007)
This papers surveys general features of functional logic languages and discusses the design of Curry.
This paper contains a survey on evaluation strategies and classes of functional logic programs.
This papers surveys the early developments in the operational principles and implementations of integrated functional logic languages.
Language Features and Semantics
Free Theorems for Functional Logic Programs (PLPV 2010)
An example driven investigation of the restrictions of free theorems in Curry.
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.
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 1998)
This paper describes the idea and the use of the encapsulated search features of Curry.
This paper motivates the use of non-deterministic functions in Curry and proposes an optimal evaluation strategy.
This paper contains the first detailed description of the operational model of Curry.
A Unified Computation Model for Declarative Programming (APPIA-GULP-PRODE 1997)
This paper contains an updated and slightly modified introduction into the computation model of Curry.
Curry: A Truly Functional Logic Language (ILPS 1995 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.
This paper describes the implementation of equational constraints and functional patterns in KiCS2.
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.
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 1999)
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.
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 1999)
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 1999)
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.
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.
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.
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.
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.
This paper describes an approach to optimize Curry programs by a stepwise transformation based on difference lists as used in logic programming.
This paper describes a partial evaluator for the narrowing-based subset of Curry and discuss its advantages w.r.t. lazy narrowing strategies.
This paper describes a partial evaluator for a subset of Curry. An implementation is available here.
This paper presents a new program analysis framework to approximate call patterns and their results in functional logic programs.
This paper presents a method to analyse the non-determinism behavior of Curry programs based on a type inferences for nonstandard types.
This paper describes a method to analyse the non-determinism behavior of Curry programs.
This paper presents CurryBrowser, a generic analysis environment for Curry programs.
This paper presents CurryDoc, a tool for the automatic generation of documentation manuals in HTML format from Curry programs.
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.
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.
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.
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 web 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.
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 (FLOPS 1999)
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.
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.
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.
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.
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.
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.
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.
This paper describes an extension of Curry to support distributed applications where a dynamically changing number of different program units must be coordinated.