Results 1  10
of
32
The Integration of Functions into Logic Programming: From Theory to Practice
 Journal of Logic Programming
, 1994
"... Abstract. Functional logic programming languages combine the most important declarative programming paradigms, and attempts to combine these paradigms have a long history. The declarative multiparadigm language Curry is influenced by recent advances in the foundations and implementation of function ..."
Abstract

Cited by 362 (59 self)
 Add to MetaCart
(Show Context)
Abstract. Functional logic programming languages combine the most important declarative programming paradigms, and attempts to combine these paradigms have a long history. The declarative multiparadigm language Curry is influenced by recent advances in the foundations and implementation of functional logic languages. The development of Curry is an international initiative intended to provide a common platform for the research, teaching, and application of integrated functional logic languages. This paper surveys the foundations of functional logic programming that are relevant for Curry, the main features of Curry, and extensions and applications of Curry and functional logic programming. 1
An Implementation of Narrowing Strategies
 Journal of the ACM
, 2001
"... This paper describes an implementation of narrowing, an essential component of implementations of modern functional logic languages. These implementations rely on narrowing, in particular on some optimal narrowing strategies, to execute functional logic programs. We translate functional logic progra ..."
Abstract

Cited by 307 (122 self)
 Add to MetaCart
This paper describes an implementation of narrowing, an essential component of implementations of modern functional logic languages. These implementations rely on narrowing, in particular on some optimal narrowing strategies, to execute functional logic programs. We translate functional logic programs into imperative (Java) programs without an intermediate abstract machine. A central idea of our approach is the explicit representation and processing of narrowing computations as data objects. This enables the implementation of operationally complete strategies (i.e., without backtracking) or techniques for search control (e.g., encapsulated search). Thanks to the use of an intermediate and portable representation of programs, our implementation is general enough to be used as a common back end for a wide variety of functional logic languages.
Operational Semantics for Declarative MultiParadigm Languages
 Journal of Symbolic Computation
, 2005
"... Abstract. In this paper we define an operational semantics for functional logic languages covering notions like laziness, sharing, concurrency, nondeterminism, etc. Such a semantics is not only important to provide appropriate language definitions to reason about programs and check the correctness ..."
Abstract

Cited by 68 (29 self)
 Add to MetaCart
(Show Context)
Abstract. In this paper we define an operational semantics for functional logic languages covering notions like laziness, sharing, concurrency, nondeterminism, etc. Such a semantics is not only important to provide appropriate language definitions to reason about programs and check the correctness of implementations but it is also a basis to develop languagespecific tools, like program tracers, profilers, optimizers, etc. First, we define a &quot;bigstep &quot; semantics in natural style to relate expressions and their evaluated results. Since this semantics is not sufficient to cover concurrency, search strategies, or to reason about costs associated to particular computations, we also define a &quot;smallstep &quot; operational semantics covering the features of modern functional logic languages.
A Semantics for Tracing Declarative MultiParadigm Programs
 In Proceedings of the 6th ACM SIGPLAN International Conference on Principles and Practice of Declarative Programming (PPDP’04
, 2004
"... We introduce the theoretical basis for tracing lazy functional logic computations in a declarative multiparadigm language like Curry. Tracing computations is a difficult task due to the subtleties of the underlying operational semantics which combines laziness and nondeterminism. In this work, we ..."
Abstract

Cited by 20 (12 self)
 Add to MetaCart
(Show Context)
We introduce the theoretical basis for tracing lazy functional logic computations in a declarative multiparadigm language like Curry. Tracing computations is a difficult task due to the subtleties of the underlying operational semantics which combines laziness and nondeterminism. In this work, we define an instrumented operational semantics that generates not only the computed values and bindings but also an appropriate data structure—a sort of redex trail—which can be used to trace computations at an adequate level of abstraction. In contrast to previous approaches, which rely solely on a transformation to instrument source programs, the formal definition of a tracing semantics improves the understanding of the tracing process. Furthermore, it allows us to formally prove the correctness of the computed trail. A prototype implementation of a tracer based on this semantics demonstrates the usefulness of our approach.
A simple rewrite notion for calltime choice semantics
 In Proc. Principles and Practice of Declarative Programming, ACM Press
, 2007
"... Nonconfluent and nonterminating rewrite systems are interesting from the point of view of programming. In particular, existing functional logic languages use such kind of rewrite systems to define possibly nonstrict nondeterministic functions. The semantics adopted for nondeterminism is callti ..."
Abstract

Cited by 20 (6 self)
 Add to MetaCart
Nonconfluent and nonterminating rewrite systems are interesting from the point of view of programming. In particular, existing functional logic languages use such kind of rewrite systems to define possibly nonstrict nondeterministic functions. The semantics adopted for nondeterminism is calltime choice, whose combination with nonstrictness is not a trivial issue that has been addressed from a semantic point of view in the Constructorbased Rewriting Logic (CRWL) framework. We investigate here how to express calltime choice and nonstrict semantics from a point of view closer to classical rewriting. The proposed notion of rewriting uses an explicit representation for sharing with letconstructions and is proved to be equivalent to the CRWL approach. Moreover, we relate this letrewriting relation (and hence CRWL) with ordinary rewriting, providing in particular soundness and completeness of letrewriting with respect to rewriting for a class of programs which are confluent in a certain semantic sense.
Lazy Context Cloning for NonDeterministic Graph Rewriting
 TERMGRAPH 2006
, 2006
"... We define a rewrite strategy for a class of nonconfluent constructorbased term graph rewriting systems and prove its correctness. Our strategy and its extension to narrowing are intended for the implementation of nonstrict nondeterministic functional logic programming languages. Our strategy is ..."
Abstract

Cited by 16 (7 self)
 Add to MetaCart
(Show Context)
We define a rewrite strategy for a class of nonconfluent constructorbased term graph rewriting systems and prove its correctness. Our strategy and its extension to narrowing are intended for the implementation of nonstrict nondeterministic functional logic programming languages. Our strategy is based on a graph transformation, called bubbling, that avoids the construction of large contexts of redexes with distinct replacements, an expensive and frequently wasteful operation executed by competitive complete techniques.
Operational Semantics for Functional Logic Languages
 Electronic Notes in Theoretical Computer Science
, 2002
"... In this work we provide a semantic description of functional logic languages covering notions like laziness, sharing, and nondeterminism. Such a semantic description is essential, for instance, to have appropriate language definitions in order to reason about programs and check the correctness of i ..."
Abstract

Cited by 14 (9 self)
 Add to MetaCart
(Show Context)
In this work we provide a semantic description of functional logic languages covering notions like laziness, sharing, and nondeterminism. Such a semantic description is essential, for instance, to have appropriate language definitions in order to reason about programs and check the correctness of implementations. First, we define a "bigstep" semantics in natural style to relate expressions and their evaluated results. Since this semantics is not su#cient to reason about the operational aspects of programs, we also define a "smallstep" operational semantics covering the main features of functional logic languages. Finally, we demonstrate the equivalence of the "smallstep" semantics and the natural semantics.
The integration of functions into logic programming
 The Journal of Logic Programming
, 1994
"... This paper presents a new program analysis framework to approximate call patterns and their results in functional logic computations. We consider programs containing nonstrict, nondeterministic operations in order to make the analysis applicable to modern functional logic languages like Curry or TO ..."
Abstract

Cited by 10 (0 self)
 Add to MetaCart
(Show Context)
This paper presents a new program analysis framework to approximate call patterns and their results in functional logic computations. We consider programs containing nonstrict, nondeterministic operations in order to make the analysis applicable to modern functional logic languages like Curry or TOY. For this purpose, we present a new fixpoint characterization of functional logic computations w.r.t. a set of initial calls. We show how programs can be analyzed by approximating this fixpoint. The results of such an approximation have various applications, e.g., program optimization as well as verifying safety properties of programs. 1
Narrowing datastructures with pointers
 In Proceedings of ICGT (International Conference of Graph Transformation). Springer LNCS 4178
, 2006
"... Abstract. We investigate the narrowing relation in a wide class of (cyclic) termgraph rewrite systems. We propose a new sound and complete narrowingbased algorithm able to solve goals in presence of data structures with pointers (e.g., circular lists, doubly linked lists etc.). We first define the ..."
Abstract

Cited by 10 (2 self)
 Add to MetaCart
(Show Context)
Abstract. We investigate the narrowing relation in a wide class of (cyclic) termgraph rewrite systems. We propose a new sound and complete narrowingbased algorithm able to solve goals in presence of data structures with pointers (e.g., circular lists, doubly linked lists etc.). We first define the class of rewrite systems we consider. Our rules provide features such as pointer (edge) redirections, relabeling of existing nodes, in addition to the creation of new nodes. Moreover, we split the set of nodes of termgraphs in two (possibly empty) subsets: (i) variables and (ii) names. Variable nodes can be mapped against any other node whereas names act as constants and thus they are supposed to match themselves. This distinction between nodes allows us to synthesize, through the narrowing process, datastructures with circular shapes. In a second step, we define the rewriting and narrowing relations. We then show the soundness and completeness of narrowing. 1
Rewriting and calltime choice: the HO case
 In Proc. 9th International Symposium on Functional and Logic Programming (FLOPS’08), volume 4989 of LNCS
, 2008
"... Abstract. It is known that the behavior of nondeterministic functions with calltime choice semantics, present in current functional logic languages, is not well described by ordinary approaches to reduction like ordinary term rewriting systems or λcalculus. The presence of HO features makes thi ..."
Abstract

Cited by 10 (5 self)
 Add to MetaCart
(Show Context)
Abstract. It is known that the behavior of nondeterministic functions with calltime choice semantics, present in current functional logic languages, is not well described by ordinary approaches to reduction like ordinary term rewriting systems or λcalculus. The presence of HO features makes things more difficult, since reasoning principles that are essential in a standard (i.e., deterministic) functional setting, like extensionality, become wrong. In this paper we propose HOletrewriting, a notion of rewriting with local bindings that turns out to be adequate for programs with HO nondeterministic functions, as it is shown by strong equivalence results with respect to HOCRWL, a previously existing semantic framework for such programs. In addition, we give a sound and complete notion of HOletnarrowing, we show by a case study the usefulness of the achieved combination of semantic and reduction notions, and finally we prove within our framework that a standard approach to the implementation of HO features, namely translation to FO, is still valid for HO nondeterministic functions. 1