We present the development of the Lucid language from the Original Lucid of the mid-1970s to the TransLucid of today. Each successive version of the language has been a generalisation of previous languages, but with a further understanding of the problems at hand. The Original Lucid (1976), originally designed for purposes of formal verification, was used to formalise the iteration in while-loop programs. The pLucid language (1982) was used to describe dataflow networks. Indexical Lucid (1987) was introduced for intensional programming, in which the semantics of a variable was understood as a function from a universe of possible worlds to ordinary values. With TransLucid, and the use of contexts as firstclass values, programming can be understood in a Cartesian framework.

From Lucid to TransLucid: Iteration, Dataflow, Intensional and Cartesian Programming

The embedding of a small but expressive language of multidimensional functional programming in a well known and widely used language of object-oriented programming leads to the combination of two radically different programming models. In this paper, we formally define the syntax and semantics of GLU♮, which can be thought of as the multidimensional core of Lucid and GLU, and we describe its implementation as a language embedded in C++. With the aid of a few examples, we argue that the marriage of the two programming models is not only compatible and natural, but also that it produces a new and interesting hybrid language. Copyright © 2004 John Wiley & Sons, Ltd.

GLU embedded in C++: a marriage between multidimensional and object-oriented programming

We develop an eductive algorithm for the efficient implementation of Multidimensional Lucid, which includes dimensions as first-class values. By focusing on simple multi-dimensional expressions, we develop a series of operational semantics, ultimately leading to an algorithm that should lead to efficient implementations of Lucid for a variety of physical architectures.

Multidimensional Lucid: Design, Semantics and Implementation

The intensional transformation is a technique that can be used in order to eliminate higher-order functions from a functional program by introducing appropriate context-manipulation operators. The transformation can be applied to a significant class of higher-order programs and results in equivalent zero-order intensional programs that can be executed in a simple demand-driven way. Despite its simplicity, the transformation has never been seriously evaluated with respect to its efficiency and potential. Certain simple implementations of the technique have been performed, but questions regarding the merits of the method have remained inconclusive. In this paper we demonstrate that the transformation can be efficiently implemented by using what we call lazy activation records, namely activation records in which some entries are filled on-demand. An evaluation of our implementation demonstrates that the technique outperforms some of the most well-known functional programming systems, for the class of programs that can be transformed.

/pdf/efficient-intensional-implementation-for-lazy-functional-3v4z4rvdhp.pdf

Efficient Intensional Implementation for Lazy Functional Languages

The branching-time transformation technique has proven to be an efficient approach for implementing functional programming languages. In this paper we demonstrate that such a technique can also be defined for logic programming languages. More specifically, we first introduce Branching Datalog, a language that can be considered as the basis for branching-temporal deductive databases. We then present a transformation algorithm from Chain Datalog programs to the class of unary Branching Datalog programs with at most one IDB atom in the body of each clause. In this way, we obtain a novel implementation approach for Chain Datalog, shedding at the same time new light on the power of branching-time logic programming.

/pdf/the-branching-time-transformation-technique-for-chain-1a7r117sgv.pdf

The Branching-Time Transformation Technique for Chain Datalog Programs

In this paper we demonstrate that a broad class of higher-order functional programs can be transformed into semantically equivalent multidimensional intensional programs that contain only nullary v...

/pdf/higher-order-functional-languages-and-intensional-logic-3ul1h64viy.pdf

WadgeW. W.

Papers

Higher-order functional languages and intensional logic