Autowrite is an experimental software tool written in Common Lisp for handling term rewrite systems and bottom-up tree automata. A graphical interface has been written using McCLIM, (the free implementation of the CLIM specification) in order to free the user of any Lisp knowledge. Software and documentation can be found at Autowrite was initially designed to check call-by-need properties of term rewrite systems. For this purpose, it implements the tree automata constructions used in [10,3,5,13] and many useful operations on terms, term rewrite systems and tree automata. In the first version of Autowrite [4], only the call-by-need properties and a few other simple properties were available from the graphical interface. This new version of Autowrite includes many new functionalities. There are new functionalities related to TRSs, but the most interesting new feature is the possibility to directly handle (load, save, combine with boolean operations) bottom-up tree automata. In addition, we have added on-line timing information. Since the first version the run-times have been considerably improved due to better choices of data structures. The first version of Autowrite was used to check call-by-need for most of the examples presented in [6]. Most of the time no alternative proofs exists. The new features allowed testing many properties of examples presented in [7] for which no easy proof can be written.

syntax . . . . . . . . . . . . . . . . . . . . . 92 5.4.2 Step 2: Abstract Syntax embedding . . . . . . . . . . . . . . 93 5.4.3 Step 3: Type embedding . . . . . . . . . . . . . . . . . . . . . 94 5.5 Relational algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 5.5.1 Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95 5.5.2 Relations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 96 5.5.3 Relational expressions . . . . . . . . . . . . . . . . . . . . . . 97 5.5.4 Restriction . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98 5.5.5 Union,Di#erence and Cartesian product . . . . . . . . . . . . 99 5.6 Embedding queries . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99 5.6.1 Step 1: Abstract syntax . . . . . . . . . . . . . . . . . . . . . 99 5.6.2 Step 2: Abstract syntax embedding . . . . . . . . . . . . . . 103 5.6.3 Step 3: Type embedding . . . . . . . . . . . . . . . . . . . . . 110 5.7 Exam marks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 5.7.1 Visual Basic . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117 5.7.2 Haskell . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118 5.8 Status and conclusions . . . . . . . . . . . . . . . . . . . . . . . . . . 120 6 The Lazy Virtual Machine 121 Contents vii 6.2 An overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123 6.3 The abstract machine . . . . . . . . . . . . . . . . . . . . . . . . . . 127 6.3.1 Basic instructions . . . . . . . . . . . . . . . . . . . . . . . . 128 6.3.2 Local definitions . . . . . . . . . . . . . . . . . . . . . . . . . 130 6.3.3 Sharing . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131 6.3.4 Recursive values . . . . . . . . . . . . . . . . . . . . . . . . . 13...

Programmers working on large software systems are faced with an extremely complex, information-rich environment. To help navigate through this, modern development environments allow flexible, multi-window browsing and exploration of the source code. Our focus in this paper is on pretty-printing algorithms that can display source code in useful, appealing ways in a variety of styles. Our algorithm is flexible, stable, and peephole-efficient. It is flexible in that it is capable of screenoptimized layouts that support source code visualization techniques such as fisheye views. The algorithm is peephole-efficient, in that it performs work proportional to the size of the visible window and not the size of the entire file. Finally, the algorithm is stable, in that the rendered view is identical to that which would be produced by formatting the entire file. This work has 2 benefits. First, it enables rendering of source codes in multiple fonts and font sizes at interactive speeds. Second, it also allows the use of powerful (but algorithmically more complex) visualization techniques (such as fish-eye views), again, at interactive speeds.

Advanced PL technology is a secret weapon in enterprise computing Chet Murthy, POPL 2007 We investigate how the need for evermore programming languages arises, and how to fulfill this need. We show how the gap between building a library using an existing language and constructing a completely new language narrows. In doing so we discuss a few of the past and current research results from the Software Technology group at Utrecht University. 1

Abstract not found

There are numerous ways to implement a parser for a given syntax; using parser combinators is a powerful approach to parsing which derives much of its power and expressiveness from the type system and semantics of the host programming language. This tutorial begins with the construction of a small library of parsing combinators. This library introduces the basics of combinator parsing and, more generally, demonstrates how domain specific embedded languages are able to leverage the facilities of the host language. After having constructed our small combinator library, we investigate some shortcomings of the naïve implementation introduced in the first part, and incrementally develop an implementation without these problems. Finally we discuss some further extensions of the presented library and compare our approach with similar libraries. 1

We present a functional approach to parsing unrestricted contextfree grammars based on Brzozowski’s derivative of regular expressions. If we consider context-free grammars as recursive regular expressions, Brzozowski’s equational theory extends without modification to context-free grammars (and it generalizes to parser combinators). The supporting actors in this story are three concepts familiar to functional programmers—laziness, memoization and fixed points; these allow Brzozowski’s original equations to be transliterated into purely functional code in about 30 lines spread over three functions. Yet, this almost impossibly brief implementation has a drawback: its performance is sour—in both theory and practice. The culprit? Each derivative can double the size of a grammar, and with it, the cost of the next derivative. Fortunately, much of the new structure inflicted by the derivative is either dead on arrival, or it dies after the very next derivative. To eliminate it, we once again exploit laziness and memoization to transliterate an equational theory that prunes such debris into working code. Thanks to this compaction, parsing times become reasonable in practice. We equip the functional programmer with two equational theories that, when combined, make for an abbreviated understanding and implementation of a system for parsing context-free languages.

Algebraic datatypes in Haskell are a powerful tool to structure application data. Unfortunately, Haskell datatypes can only be used in-memory. When information is too large to fit in application memory or has to survive the running time of a single process, the information has to be marshalled to and from a persistent storage. The current systems available for persistent storage in Haskell all have some drawbacks. Either the structure of these storage systems does not fit the algebraic datatypes of Haskell, or the systems do not allow partial access to the persistent storage. In this document we describe a new storage framework for Haskell that uses generic programming to allow the persistent storage of a large class of functional data structures. The system allows access to parts of the data structures, this prevents reading in the entire data structure when only small parts are needed. Partial access allows the operations on the persistent data structures to run with the same asymptotic running time as their in-memory counterparts. The framework uses a generic annotation system to automatically lift operations