Higher Order Attribute Grammars (HAGs) are an extension of normal attribute grammars in the sense that the distinction between the domain of parse-trees and the domain of attributes has disappeared: parse trees may be computed in attributes and grafted to the parse tree at various places. As a result semantic functions may be described by attribute evaluation.

This paper argues that comprehensions, a construct found in some programming languages, are a good query notation for DBPLs. It is shown that, like many other query notations, comprehensions can be smoothly integrated into DBPLs and allow queries to be expressed clearly, concisely and efficiently. More significantly, two advantages of comprehensions are demonstrated. The first advantage is that, unlike conventional notations, comprehension queries combine computational power with ease of optimisation. That is, not only can comprehension queries express both recursion and computation, but equivalent comprehension transformations exist for all of the major conventional optimisations. The second advantage is that comprehensions provide a uniform notation for expressing and performing some optimisation on queries over several bulk data types. The bulk types that comprehensions can be defined over include sets, relations, bags and lists. A DBPL can also be automatically extended to provide and partially optimise comprehension queries over new bulk types constructed by the application programmer, providing that the new type has some well-defined properties. 1

The task of increasing the efficiency of database queries has recieved considerable attention. In this paper we describe the improvement of queries expressed as list comprehensions in a lazy functional language. The database literature identifies four algebraic and two implementation-based improvement strategies. For each strategy we show an equivalent improvement for queries expressed as list comprehensions. This means that welldeveloped database algorithms that improve queries using several of these strategies can be emulated to improve comprehension queries. We are also able to improve queries which require greater power than that provided by the relational algebra. Most of the improvements entail transforming a simple, inefficient query into a more complex, but more efficient form. We illustrate each improvement using examples drawn from the database literature. 1 Introduction The functional programming community is often accused of being too inward looking. Functional languages a...

Animation is a temporally continuous phenomenon, but is typically programmed in terms of a discrete sequence of changes. The use of discreteness serves to accommodate the machine that is presenting an animation, rather than the person modeling an animation with the help of a computer. Using a continuous model of time for animation allows for natural specification, avoiding some artificial details, but is difficult to implement with generality, robustness and efficiency. This paper presents and motivates continuous modeled animation, and sketches out a naive functional implementation for it. An examination of some of the practical problems with this implementation leads to several alternate representations, all of which have difficulties in themselves, some quite subtle. We hope that the insights and techniques discussed in this paper lead to still better representations, so that animation may be specified in natural terms without significant loss of performance.

A Functional Database Phil Trinder D.Phil. Thesis Wolfson College Michaelmas Term, 1989 This thesis explores the use of functional languages to implement, manipulate and query databases. Implementing databases. A functional language is used to construct a database manager that allows efficient and concurrent access to shared data. In contrast to the locking mechanism found in conventional databases, the functional database uses data dependency to provide exclusion. Results obtained from a prototype database demonstrate that data dependency permits an unusual degree of concurrency between operations on the data. The prototype database is used to exhibit some problems that seriously restrict concurrency and also to demonstrate the resolution of these problems using a new primitive. The design of a more realistic database is outlined. Some restrictions on the data structures that can be used in a functional database are also uncovered. Manipulating databases. Functions over the database a...

. When evaluation in functional programming languages is explained using -calculus and/or term rewriting systems, expressions and function definitions are often defined as terms, that is as trees. Similarly, the collection of all terms is defined as a forest, that is a directed, acyclic graph where every vertex has at most one incoming edge. Concrete implementations usually drop the last restriction (and sometimes acyclicity as well), i.e. many terms can share a common subterm, meaning that different paths of subterm edges reach the same vertex in the graph. Any vertex in such a graph represents a term. A term is represented uniquely in such a graph if there are no two different vertices representing it. Such a representation can be established by using hash-consing for the creation of heap objects. We investigate the consequences of adopting uniqueness in this sense as a leitmotiv for implementation (called Unlimp), i.e. not allowing any two different vertices in a graph to represent ...

this paper.

Factotum is a software system for implementing symbolic computing systems, such as BDDs and tuple sets, that critically rely on sharing of equivalent subterms. It provides an subterm sharing facility that is automatic and systematic, analogously to the way that automatic memory management is provided by a garbage collector. It also provides a high-level programming interface suitable for use in multithreaded applications. We describe both the theoretical underpinnings and practical aspects of Factotum, show some examples, and report on some recent experiments. 1 Introduction While automatic garbage collection[McC60, Wil95] has become an accepted practice for managing memory-intensive applications, automatic sharing management is significantly less developed. Sharing of equivalent data structures in memory is of course critical for reasonable performance in many otherwise exponential computations, and is well-developed from an algorithmic standpoint, just as explicit allocation and dea...

Jungle evaluation is an approach to define term rewriting with sharing based on graph grammars. This approach preserves important properties of term rewriting like termination, and confluence for terminating systems (under mild restrictions). In this paper, term rewriting with sharing is further accelerated, by memoization known from functional programming languages: The result of evaluating a function with some arguments is tabulated so that it can be looked up later on when the function is re-applied to the same arguments. We show that term rewriting with sharing and memoization is correct and complete w.r.t. jungle evaluation if the rules are non-overlapping and non-looping. Redundant re-evaluation of functions is avoided, independent of a particular strategy for applying evaluation rules. 1 Introduction Term rewriting is a basis for prototyping algebraic specifications of abstract data types, and a foundation of functional programming languages (see [DJ90] and [Klo90] for overvie...

This paper presents a casestudy of how this limitation of OOP was overcome using aspect-oriented programming techniques, such that the performance problems were adequately addressed without compromising the original OOP architecture of the system