Abstract not found

We present a formal method of functional program development based on step-by-step transformation. In their most abstract form, specifications are essentially predicates that relate the result of the specified program to the free variables of that program. In their most concrete form, specifications are simply programs in a functional programming language. Development from abstract specifications to programs is calculational. Using logic in the specification language has many advantages. Importantly it allows nondeterministic specifications to be given, and thus does not force overspecification.

This paper explores the idea of generic programming in which programs are parameterised by data types. Part of the constructive theory of lists, specically the part dealing with properties of segments, is generalised in two ways: from lists to arbitrary inductive data types, and from functions to relations. The new theory is used to solve a generic problem about segments. 1 Introduction To what extent is it possible to construct programs without knowing exactly what data types are involved? At rst sight this may seem a strange question, but consider the case of pattern matching. Over lists, this problem can be formulated in terms of two strings, a pattern and a text; the object is to determine if and where the pattern occurs as a segment of the text. Now, pattern matching can be generalised to other data types, including arrays and trees of various kinds; the essential step is to be able to dene the notion of `segment' in these types. So the intriguing question arises: can one...

. In this paper we demonstrate that the basic rules and calculational techniques used in two extensively documented program derivation methods can be expressed, and, indeed, can be generalised within a relational theory of datatypes. The two methods to which we refer are the so-called "Bird-Meertens formalism" (see [22]) and the "Dijkstra-Feijen calculus" (see [15]). The current paper forms an abridged, though representative, version of a complete account of the algebraic properties of the Boom hierarchy of types [19, 18]. Missing is an account of extensionality and the so-called crossproduct. 1 Introduction The "Bird-Meertens formalism" (to be more precise, our own conception of it) is a calculus of total functions based on a small number of primitives and a hierarchy of types including trees and lists. The theory was set out in an inspiring paper by Meertens [22] and has been further refined and applied in a number of papers by Bird and Meertens [8, 9, 11, 12, 13]. Its beauty deriv...

This paper consists of some preliminary steps towards the construction of a new calculus for modelling nondeterministic speci cations as multirelations. The model is appealing because it combines some of the merits of the existing models of relations and predicate transformers. Like relations, multirelations model speci cations from initial to nal state, and like predicate transformers, they can model two kinds of nondeterminism within a single framework. This is achieved by mapping input values to postconditions rather than output values. So the multirelational model is more expressive than that of relations, but not quite as transparent. Therefore we recommend its use only for the description of systems that cannot be expressed more simply using ordinary relations

This paper presents the Visual Haskell language. Visual Haskell is intended as i) a means of visualising Haskell programs, and ii) as a complementary programming notation to standard Haskell. The syntax of Visual Haskell is specified by first giving a translation from Haskell into an intermediate, textual form; the visual syntax is then specified as a direct translation from the intermediate form into visual representations. Visual Haskell is kept as close to Haskell as possible, in the hope that it could be used in a "two-view" programming system. Several examples of function definitions illustrate how Visual Haskell looks and is used. Visual Haskell is incomplete, lacking syntax for modules, type declarations, type classes and instances, arrays, and user-defined operators. These are seen as temporary omissions rather than insurmountable drawbacks. 1 Introduction This paper presents Visual Haskell, my attempt to develop a visual equivalent for the Haskell functional language [4]. Vis...

The purpose of the Adl project is to demonstrate the efficient implementation of data parallel functional programming, firstly on the TMC CM-5 but ultimately on other parallel machines. We have designed a small polymorphic non-recursive language (Adl), which emphasizes high-level operations (second-order combinators) on aggregate structures. The Adl project incorporates the formal description of Adl semantics, translation and optimization, and the design of an abstract data-parallel machine which describes not only the CM-5 but also other distributed memory multicomputers and hence encourages architecture-independent code generation. An executable natural semantic description of translation to the Bird-Meertens Formalism (BMF) has been completed; similar techniques are being used with an optimizer. We also describe an implementation of the abstract machine for the CM-5 implementation. 1 Introduction Exploitation of parallelism in applications is a very attractive concept, but there is...

A categorical model of object-oriented systems is proposed and denoted using a -calculus. The model is used to provide a definition of design refinement. An example system is rigorously developed in Java from an initial user requirements by refining an initial design. Contents 1 Introduction 1 2 Object-Oriented Design Features 2 3 Object Behaviour 3 3.1 Object States . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3 3.2 Object Calculation Graphs . . . . . . . . . . . . . . . . . . . . . 4 3.3 Object-Oriented Designs . . . . . . . . . . . . . . . . . . . . . . . 6 3.4 Object Semantics . . . . . . . . . . . . . . . . . . . . . . . . . . . 6 3.5 Behaviour Refinement . . . . . . . . . . . . . . . . . . . . . . . . 7 4 Object-Oriented Design Notation 8 4.1 Behaviour Functions . . . . . . . . . . . . . . . . . . . . . . . . . 9 4.2 Example Behaviour Functions . . . . . . . . . . . . . . . . . . . . 10 4.3 Message Handling . . . . . . . . . . . . . . . . . . . . . . . . . . 11 ...

Abstract. We introduce a semi-automated proof system for basic category-theoretic reasoning. It is based on a first-order sequent calculus that captures the basic properties of categories, functors and natural transformations as well as a small set of proof tactics that automate proof search in this calculus. We demonstrate our approach by automating the proof that the functor categories Fun[C × D,E] and Fun[C,Fun[D,E]] are naturally isomorphic. 1

Abstract. Pattern matching is advantageous for understanding and reasoning about function definitions, but it tends to tightly couple the interface and implementation of a datatype. Significant effort has been invested in tackling this loss of modularity; however, decoupling patterns from concrete representations while maintaining soundness of reasoning has been a challenge. Inspired by the development of invertible programming, we propose an approach to abstract datatypes based on a rightinvertible language rinv—every function has a right (or pre-) inverse. We show how this new design is able to permit a smooth incremental transition from programs with algebraic datatypes and pattern matching, to ones with proper encapsulation (implemented as abstract datatypes), while maintaining simple and sound reasoning.