Results 1  10
of
11
Overlapping Rules and Logic Variables in Functional Logic Programs
 In Twenty Second International Conference on Logic Programming
, 2006
"... Abstract. Functional logic languages extend purely functional languages with two features: operations defined by overlapping rules and logic variables in both defining rules and expressions to evaluate. In this paper, we show that only one of these features is sufficient in a core language. On the o ..."
Abstract

Cited by 34 (16 self)
 Add to MetaCart
Abstract. Functional logic languages extend purely functional languages with two features: operations defined by overlapping rules and logic variables in both defining rules and expressions to evaluate. In this paper, we show that only one of these features is sufficient in a core language. On the one hand, overlapping rules can be eliminated by introducing logic variables in rules. On the other hand, logic variables can be eliminated by introducing operations defined by overlapping rules. The proposed transformations between different classes of programs not only give a better understanding of the features of functional logic programs but also may simplify implementations of functional logic languages. 1
A Virtual Machine for Functional Logic Computations
 In Proc. of the 16th International Workshop on Implementation and Application of Functional Languages (IFL 2004
, 2005
"... Abstract. We describe the architecture of a virtual machine for executing functional logic programming languages. A distinguishing feature of our machine is that it preserves the operational completeness of nondeterministic programs by concurrently executing a pool of independent computations. Each ..."
Abstract

Cited by 18 (17 self)
 Add to MetaCart
Abstract. We describe the architecture of a virtual machine for executing functional logic programming languages. A distinguishing feature of our machine is that it preserves the operational completeness of nondeterministic programs by concurrently executing a pool of independent computations. Each computation executes only rootneeded sequential narrowing steps. We describe the machine’s architecture and instruction set, and show how to compile overlapping inductively sequential programs to sequences of machine instructions. The machine has been implemented in Java and in Standard ML. 1
Purely Functional Lazy Nondeterministic Programming
"... Functional logic programming and probabilistic programming have demonstrated the broad benefits of combining laziness (nonstrict evaluation with sharing of the results) with nondeterminism. Yet these benefits are seldom enjoyed in functional programming, because the existing features for nonstric ..."
Abstract

Cited by 12 (3 self)
 Add to MetaCart
Functional logic programming and probabilistic programming have demonstrated the broad benefits of combining laziness (nonstrict evaluation with sharing of the results) with nondeterminism. Yet these benefits are seldom enjoyed in functional programming, because the existing features for nonstrictness, sharing, and nondeterminism in functional languages are tricky to combine. We present a practical way to write purely functional lazy nondeterministic programs that are efficient and perspicuous. We achieve this goal by embedding the programs into existing languages (such as Haskell, SML, and OCaml) with highquality implementations, by making choices lazily and representing data with nondeterministic components, by working with custom monadic data types and search strategies, and by providing equational laws for the programmer to reason about their code.
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 11 (7 self)
 Add to MetaCart
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.
On the correctness of bubbling
 17th International Conference on Rewriting Techniques and Applications (RTA’06
, 2006
"... Abstract. Bubbling, a recently introduced graph transformation for functional logic computations, is wellsuited for the reduction of redexes with distinct replacements. Unlike backtracking, bubbling preserves operational completeness; unlike copying, it avoids the upfront construction of large con ..."
Abstract

Cited by 6 (4 self)
 Add to MetaCart
Abstract. Bubbling, a recently introduced graph transformation for functional logic computations, is wellsuited for the reduction of redexes with distinct replacements. Unlike backtracking, bubbling preserves operational completeness; unlike copying, it avoids the upfront construction of large contexts of redexes, an expensive and frequently wasteful operation. We recall the notion of bubbling and offer the first proof of its completeness and soundness with respect to rewriting. 1 Introduction Nondeterminism is one of the most appealing features of functional logic programing. A program is nondeterministic when its execution may evaluate some expression that has multiple results. To better understand this concept, considera program to color a map of the Pacific Northwest so that no pair of adjacent states shares a color. The following declarations, in Curry [15], define the wellknown topology of the problem: data State = WA  OR  ID  BC states = [WA,OR,ID,BC] adjacent = [(WA,OR),(WA,ID),(WA,BC),(OR,ID),(ID,BC)] (1)
On the correctness of the pulltab transformation
 In To appear in Proceedings of the 27th International Conference on Logic Programming (ICLP
, 2011
"... Abstract. We present a new approach to the execution of functional logic programs. Our approach relies on definitional trees for the deterministic portions of a computation and on a graph transformation, called pulltab, for the nondeterministic portions. This transformation moves, one level at a t ..."
Abstract

Cited by 3 (2 self)
 Add to MetaCart
Abstract. We present a new approach to the execution of functional logic programs. Our approach relies on definitional trees for the deterministic portions of a computation and on a graph transformation, called pulltab, for the nondeterministic portions. This transformation moves, one level at a time, nondeterministic choices towards the root of the graph representing the state of a computation. With respect to needbased strategies for functional logic computations, our approach executes only localized graph replacements, a property that characterizes it as “pay as you go ” and makes it suitable for parallel execution. 1
Extra Variables Can Be Eliminated from Functional Logic Programs. ENTCS (this volume
"... Programs in modern functional logic languages are rewrite systems following the constructor discipline but where confluence and termination are not required, thus defining possibly non strict and nondeterministic functions. While in practice and in some theoretical papers rewrite rules can contain ..."
Abstract

Cited by 2 (1 self)
 Add to MetaCart
Programs in modern functional logic languages are rewrite systems following the constructor discipline but where confluence and termination are not required, thus defining possibly non strict and nondeterministic functions. While in practice and in some theoretical papers rewrite rules can contain extra variables in right hand sides, some other works and techniques do not consider such possibility. We address in this paper the question of whether extra variables can be eliminated in such kind of functional logic programs, proving the soundness and completeness of an easy solution that takes advantage of the possibility of nonconfluence. Although the focus of the paper is mainly theoretical, we give some first steps towards the practical usability of the technique.
Toward a Feasible Functional Logic Compiler Employing Fair Search
, 2005
"... Traditionally, implementations for functional logic languages (FLP) have used depthfirst search to implement narrowing, a wellknown search strategy. While this approach yields good performance, it is unnecessarily restrictive in the sense that some programs lead to nontermination (the search comp ..."
Abstract
 Add to MetaCart
Traditionally, implementations for functional logic languages (FLP) have used depthfirst search to implement narrowing, a wellknown search strategy. While this approach yields good performance, it is unnecessarily restrictive in the sense that some programs lead to nontermination (the search computes forever in one part of the search space, failing to consider the rest) when clearly they should yield results. As a result, a number of recent FLP research efforts have focused on designing efficient FLP systems based on breadthfirst search strategies, which hold an important fairness property: if a solution is known to exist, it will (eventually) be found. The work presented in this paper addresses issues of efficiency in the context of FLC, a FLP compiler that employs fair search and a novel application of firstclass stores in its implementation of narrowing. We show that in order to be tractable, FLC needs an efficient data representation