Abstract not found

The design and implementation of efficient aggregate data structures has been an important issue in functional programming. It is not clear how to select a good representation for an aggregate when access patterns to the aggregate are highly variant, or even unpredictable. Previous approaches rely on compile--time analyses or programmer annotations. These methods can be unreliable because they try to predict program behaviors before they are executed. We propose a probabilistic approach, which is based on Markov processes, for automatic selection of data representations. The selection is modeled as a random process moving in a graph with weighted edges. The proposed approach employs coin tossing at run--time to aid choosing suitable data representations. The transition probability function used by the coin tossing is constructed in a simple and common way from a measured cost function. We show that, under this setting, random selection of data representations can be quite effective. Th...

The array update problem in a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. We devise a very simple, fully persistent data structure to tackle this problem such that ffl each incremental update costs O(1) worst--case time, ffl a voluminous sequence of r reads cost in total O(r) amortized time, and ffl the data structure use O(n + u) space, where n is the size of the array and u is the total number of updates. A sequence of r reads is voluminous if r is \Omega\Gamma n) and the sequence of arrays being read forms a path of length O(r) in the version tree. A voluminous sequence of reads may be mixed with updates without affecting either the performance of reads or updates. An immediate consequence of the above result is that if a functional program is single--threaded, then the data structure provides a simple and efficient implementation of funct...

The array update problem in the implementation of a purely functional language is the following: once an array is updated, both the original array and the newly updated one must be preserved to maintain referential transparency. Previous approaches have mainly based on the detection or enforcement of single--threaded accesses to an aggregate, by means of compiler--time analyses or language restrictions. These approaches cannot deal with aggregates which are updated in a multi--threaded manner. Baker's shallow binding scheme can be used to implement multi--threaded functional arrays. His scheme, however, can be very expensive if there are repeated alternations between long binding paths. We design a scheme that fragments binding paths randomly. The randomization scheme is on--line, simple to implement, and its expected performance comparable to that of the optimal off--line solutions. All this is achieved without using compiler--time analyses, and without restricting the languages. The ...

Lisp has become the language of choice for many applications such as artificial intelligence programs or symbol manipulation. The original implementation of Lisp 1.5 was a concise, elegant statement of the semantics of the language. Although production Lisp systems have undergone significant development and evolution since Lisp 1.5, including the development of sophisticated compilers, there have been few significant theoretical improvements in the implementations of these systems. Most improvements, such as arrays or shallow-binding, have been made more for the sake of speed than for the sake of storage. A notable exception to this is the technique of tail recursion, which can save more than just stack space. We believe that more can be done to reduce the storage requirements of Lisp programs. Although in many instances, the Lisp programmer can reduce the storage requirements of his program by deleting unneeded pointers as soon as possible, there is nothing he can do about systematic ...

this paper. In short, the choice of which "macros" are "special forms" is just as arbitrary as the choice of a axes in a coordinate system for the Cartesian X-Y plane---e.g., some sets of macros are "linearly independent", and some sets of macros "span" the space of special forms. Some of our emulations may only be approximate, in the sense that certain syntactic variations are not supported, and certain error conditions are not recognized. These emulations are meant to be only a starting point for a serious effort in pinning down the semantics of Common Lisp, and significant additional effort will be required to complete this task.

The paper discusses different aspects of hash tables as a data structure in a Horn clause language such as Prolog, e.g., semantics, implementation and applications. Hash tables are a new concept in Prolog since they can not be efficiently implemented in the language itself. We give informal semantics for hash tables as partial functions on logical terms. We are careful to ensure that we can represent the hash tables as logical terms in order to make the ordinary syntactic unification apply. The implementation is a generalisation of the method suggested by Eriksson and Rayner. Their "mutable arrays" are a special case of our multiple version hash tables. The implementation has been used in Tricia, an implementation of Prolog developed at Uppsala University. Hash tables open application areas previously beyond the efficiency limits of Prolog. Application programs taking great benefit from the hash tables have been written in Tricia. An earlier version of this paper was presented at the 4...

. Run-time code generation (RTCG) and just-in-time compilation (JIT) are features of modern programming systems to strike the balance between generality and efficiency. Since RTCG and JIT techniques are not portable and notoriously hard to implement, we propose code splicing as an alternative for dynamically-typed higher-order programming languages. Code splicing combines precompiled pieces of code using higher-order functions. While this approach cannot achieve the performance of compiled code, it can support some intriguing features: -- very fast "compilation" times; -- satisfactory run times, compared with interpretation; -- simple interfacing with compiled code; -- portability. Starting from implementation models for functional languages we develop and evaluate several approaches to code splicing. This leads to some new insights into compilation techniques for functional programming languages, among them a compositional compilation schema to SKI-combinators. The pro...

te is preserved, and information is copied only as needed to maintain this illusion. This incremental change operation is useful, for example, in making private annotations to hypermedia networks, counterfactuals in knowledge bases, or incremental redisplay algorithms in computer graphics. 2 Marcotte: A part of a plant capable of regenerating missing parts, thus propagating a new plant capable of independent growth. from the French Botanical Dictionary Two possibilities for the representation of movement: Move the focus or move the context? Suppose you are driving a car through the streets of a city. Consider two different representations of the movement of the car through the city. The first representation is a map of the city, a static network of connections between streets. The itinerary of the car could be represented by a moving point indicating the instantaneous position of the car at every moment. The other representation is what the driver sees t

Abstract. Pure functional programming language offer many advantages over impure languages. Unfortunately, the absence of destructive update, imposes a complexity barrier. In imperative languages, there are algorithms and data structures with better complexity. We present our project for combining existing program transformation techniques to transform inefficient pure data structures into impure ones with better complexity. As a consequence, the programmer is not exposed to the impurity and retains the advantages of purity. 1