Abstract. We introduce a new native code compiler for Curry codenamed Sprite. Sprite is based on the Fair Scheme, a compilation strategy that provides instructions for transforming declarative, non-deterministic programs of a certain class into imperative, deterministic code. We outline salient features of Sprite, discuss its implementation of Curry programs, and present benchmarking results. Sprite is the first-to-date operationally complete implementation of Curry. Preliminary results show that ensuring this property does not incur a significant penalty.

Abstract. We present a compilation scheme for a functional logic programming language. The input program to our compiler is a constructor-based graph rewriting system in a non-confluent, but well-behaved class. This input is an intermediate representation of a functional logic program in a language such as Curry or T OY. The output program from our compiler consists of three procedures that make recursive calls and execute both rewrite and pull-tab steps. This output is an intermediate representation that is easy to encode in any number of programming languages. Our design evolves the Basic Scheme of Antoy and Peters by removing the "left bias" that prevents obtaining results of some computations-a behavior related to the order of evaluation, which is counter to declarative programming. The benefits of this evolution are not only the strong completeness of computations, but also the provability of non-trivial properties of these computations. We rigorously describe the compiler design and prove some of its properties. To state and prove these properties, we introduce novel definitions of "need" and "failure." For non-confluent constructor-based rewriting systems these concepts are more appropriate than the classic definition of need of Huet and Levy.

No abstract

We present an approach to rewriting in inductively sequential rewriting systems with a very distinctive feature. In the class of systems that we consider, any reducible term defines a needed step, a step that must be executed by any rewriting computation that produces the term's normal form. We show an implementation of rewriting computations that avoids executing some needed steps. We avoid executing these steps by defining functions that compute a reduct of a step without the explict construction or presence of the redex. Our approach improves the efficiency of many computations-in some cases by one or two orders of magnitude. Our work is motivated by and applicable to the implementation of functional logic programming languages.

This paper describes a VLSI layout editor implemented on the Macintosh and IBM personal computers. The editor is capable of manipulating integrated circuit designs of complexity exceeding 50,000 transistors on a standard Macintosh Plus computer. The paper discusses the design tradeoffs necessary to implement a program of this capability on small computers.