Tinte: developing a prototype for typesetting music in Clean : a case study

This paper describes the development of a typesetting program for music in the lazy functional programming language Clean. The system transforms a description of the music to be typeset in a dvi-file just like TEX does with mathematical formulae. The implementation makes heavy use of higher order functions. It has been implemented in just a few weeks and is able to typeset quite impressive examples. The system is easy to maintain and can be extended to typeset arbitrary complicated musical constructs. The paper can be considered as a status report of the implementation as well as a reference manual for the resulting system

Termination proofs for a lazy functional language by abstract reduction : (draft)

Automatic termination proofs of functional programming languages are an often challenged problem Most work in this area is done on strict languages Orderings for arguments of recursive calls are generated In lazily evaluated languages arguments for functions are not necessarily evaluated to a normal form It is not a trivial task to de ne orderings on expressions that are not in normal form or that do not even have a normal form We propose a method based on an abstract reduction process that reduces up to the point when su cient ordering relations can be found The proposed method is able to nd termination proofs for lazily evaluated programs that involve non terminating subexpressions Analysis is performed on a higher order polymorphic typed language and termi nation of higher order functions can be proved too The calculus can be used to derive information on a wide range on di erent notions of termination

Default Reasoning with a Constraint Resolution Principle

. Common non-monotonic deduction systems such as Reiters default logic or inheritance networks must handle the multiple extension problem, i.e. generally they have distinct consistent sets of conclusions (extensions) which can be drawn from a theory. Most of these systems do not provide any control structure that helps to determine in which of these extensions inferences are made. Default proof theories are in most cases only able to prove if a sentence is in at least one extension. We create a resolution based system for default reasoning where an explicit control set can be built during reasoning and where default assumptions made in a deduction are remembered as constraints. The resulting system is a cumulative default logic which assures an even stricter cumulativity than Brewka's Cumulative Default Logic and is strong enough to express Poole's Framework for default reasoning. It turns out that the created system ranges from the logic with restricted quantifiers of H.J.Burckert via..

Proving Termination of Higher-Order Functional Programs with a Tableau-like Calculus

We apply the techniques from tableau calculi to the termination analysis of programs written in a lazy, higher-order, and polymorphically typed functional programming language like Haskell. The termination analysis uses a higher-order, lazy functional core language. Laziness prevents applicability of termination orderings. We show that the combination of a tableaux that represents reduction possibilities with a method that computes termination orderings only for particular expressions is a successful method to find out whether a lazy functional program is terminating. The method has been implemented in Haskell and is able to detect termination of all functions in one of its own modules

Modular termination of r-consistent and left-linear term rewriting systems

Abstract. A modular property of term rewriting systems is one that holds for the direct sum of two disjoint term rewriting systems iff it holds for every involved term rewriting system. A term rewriting system is r-consistent iff there is no term that can be rewritten to two different variables. We show that the subclass of left-linear and r-consistent term rewriting systems has the modular termination property. This subclass may also contain nonconfluent term rewriting systems. Since confluence implies r-consistency, this constitutes a generalisation of the theorem of Toyama, Klop, and Barendregt on the modularity of termination for confluent and left-linear term rewriting systems.

Efficient strictness analysis of Haskell in Haskell using abstract reduction

The extraction of strictness information marks an indispensable element of an efficient compilation of lazy functional languages like Haskell. Based on the method of abstract reduction we have developed an e cient strictness analyser for a core language of Haskell. It is completely written in Haskell and compares favourably with known implementations. The implementation is based on the G#-machine, which is an extension of the G-machine that has been adapted to the needs of abstract reduction