7 research outputs found
A Relational Derivation of a Functional Program
This article is an introduction to the use of relational calculi in deriving programs. Using the relational caluclus Ruby, we derive a functional program that adds one bit to a binary number to give a new binary number. The resulting program is unsurprising, being the standard quot;, but the derivation illustrates a number of points about working with relations rather than with functions
A Relational Derivation of a Functional Program
This article is an introduction to the use of relational calculi in deriving programs. Using the relational caluclus Ruby, we derive a functional program that adds one bit to a binary number to give a new binary number. The resulting program is unsurprising, being the standard quot;, but the derivation illustrates a number of points about working with relations rather than with functions
The Ruby Interpreter
Ruby is a relational calculus for designing digital circuits. This document is a guide to the Ruby interpreter, which allows a special class of quot; Ruby programs to be executed. The Ruby interpreter is written in the functional programming language Lazy ML, and is used under the interactive Lazy ML system
Between functions and relations in calculating programs
This thesis is about the calculational approach to programming, in which one derives programs from specifications. One such calculational paradigm is Ruby, the relational calculus developed by Jones and Sheeran for describing and designing circuits. We identify two shortcomings with derivations made using Ruby. The first is that the notion of a program being an implementation of a specification has never been made precise. The second is to do with types. Fundamental to the use of type information in deriving programs is the idea of having types as special kinds of programs. In Ruby, types are partial equivalence relations (pers). Unfortunately, manipulating some formulae involving types has proved difficult within Ruby. In particular, the preconditions of the ‘induction’ laws that are much used within program derivation often work out to be assertions about types; such assertions have typically been verified either by informal arguments or by using predicate calculus, rather than by applying algebraic laws from Ruby.
In this thesis we address both of the shortcomings noted above. We define what it means for a Ruby program to be an implementation, by introducing the notion of a causal relation, and the network denoted by a Ruby program. A relation is causal if it is functional in some structural way, but not necessarily from domain to range; a network captures the connectivity between the primitive relations in a program. Moreover, we present an interpreter for Ruby programs that are implementations. Our technique for verifying an assertion about types is to first express it using operators that give the best left and right types for a relation, and then verify this assertion by using algebraic properties of these operators
Between functions and relations in calculating programs
This thesis is about the calculational approach to programming, in which one derives programs from specifications. One such calculational paradigm is Ruby, the relational calculus developed by Jones and Sheeran for describing and designing circuits. We identify two shortcomings with derivations made using Ruby. The first is that the notion of a program being an implementation of a specification has never been made precise. The second is to do with types. Fundamental to the use of type information in deriving programs is the idea of having types as special kinds of programs. In Ruby, types are partial equivalence relations (pers). Unfortunately, manipulating some formulae involving types has proved difficult within Ruby. In particular, the preconditions of the ‘induction’ laws that are much used within program derivation often work out to be assertions about types; such assertions have typically been verified either by informal arguments or by using predicate calculus, rather than by applying algebraic laws from Ruby.
In this thesis we address both of the shortcomings noted above. We define what it means for a Ruby program to be an implementation, by introducing the notion of a causal relation, and the network denoted by a Ruby program. A relation is causal if it is functional in some structural way, but not necessarily from domain to range; a network captures the connectivity between the primitive relations in a program. Moreover, we present an interpreter for Ruby programs that are implementations. Our technique for verifying an assertion about types is to first express it using operators that give the best left and right types for a relation, and then verify this assertion by using algebraic properties of these operators
The design and implementation of a relational programming system.
The declarative class of computer languages consists mainly of two paradigms
- the logic and the functional. Much research has been devoted in recent years
to the integration of the two with the aim of securing the advantages of both
without retaining their disadvantages. To date this research has, arguably, been
less fruitful than initially hoped. A large number of composite functional/logical
languages have been proposed but have generally been marred by the lack of a
firm, cohesive, mathematical basis. More recently new declarative paradigms,
equational and constraint languages, have been advocated. These however do
not fully encompass those features we perceive as being central to functional and
logic languages. The crucial functional features are higher-order definitions, static
polymorphic typing, applicative expressions and laziness. The crucial logic features are ability to reason about both functional and non-functional relationships
and to handle computations involving search.
This thesis advocates a new declarative paradigm which lies midway between
functional and logic languages - the so-called relational paradigm. In a relationallanguage program and data alike are denoted by relations. All expressions
are relations constructed from simpler expressions using operators which form
a relational algebra. The impetus for use of relations in a declarative language
comes from observations concerning their connection to functional and logic programming. Relations are mathematically more general than functions modelling
non-functional as well as functional relationships. They also form the basis of
many logic languages, for example, Prolog.
This thesis proposes a new relational language based entirely on binary relations, named Drusilla. We demonstrate the functional and logic aspects of
Drusilla. It retains the higher-order objects and polymorphism found in modern functional languages but handles non-determinism and models relationships
between objects in the manner of a logic language with notion of algorithm being composed of logic and control elements. Different programming styles -
functional, logic and relational- are illustrated.
However, such expressive power does not come for free; it has associated with
it a high cost of implementation. Two main techniques are used in the necessarily
complex language interpreter. A type inference system checks programs to ensure
they are meaningful and simultaneously performs automatic representation selection for relations. A symbolic manipulation system transforms programs to improve.
efficiency of expressions and to increase the number of possible representations
for relations while preserving program meaning
Between functions and relations in calculating programs
This thesis is about the calculational approach to programming, in which one derives programs from specifications. One such calculational paradigm is Ruby, the relational calculus developed by Jones and Sheeran for describing and designing circuits. We identify two shortcomings with derivations made using Ruby. The first is that the notion of a program being an implementation of a specification has never been made precise. The second is to do with types. Fundamental to the use of type information in deriving programs is the idea of having types as special kinds of programs. In Ruby, types are partial equivalence relations (pers). Unfortunately, manipulating some formulae involving types has proved difficult within Ruby. In particular, the preconditions of the ‘induction’ laws that are much used within program derivation often work out to be assertions about types; such assertions have typically been verified either by informal arguments or by using predicate calculus, rather than by applying algebraic laws from Ruby.In this thesis we address both of the shortcomings noted above. We define what it means for a Ruby program to be an implementation, by introducing the notion of a causal relation, and the network denoted by a Ruby program. A relation is causal if it is functional in some structural way, but not necessarily from domain to range; a network captures the connectivity between the primitive relations in a program. Moreover, we present an interpreter for Ruby programs that are implementations. Our technique for verifying an assertion about types is to first express it using operators that give the best left and right types for a relation, and then verify this assertion by using algebraic properties of these operators