Abstract not found

At present, the field of declarative programming is split into two main areas based on different formalisms; namely, functional programming, which is based on lambda calculus, and logic programming, which is based on firstorder logic. There are currently several language proposals for integrating the expressiveness of these two models of computation. In this thesis we work towards an integration of the methodology from the two research areas. To this end, we propose an algebraic approach to reasoning about logic programs, corresponding to the approach taken in functional programming. In the first half of the thesis we develop and discuss a framework which forms the basis for our algebraic analysis and transformation methods. The framework is based on an embedding of definite logic programs into lazy functional programs in Haskell, such that both the declarative and the operational semantics of the logic programs are preserved. In spite of its conciseness and apparent simplicity, the embedding proves to have many interesting properties and it gives rise to an algebraic semantics of logic programming. It also allows us to reason about logic programs in a simple calculational style, using rewriting and the algebraic laws of combinators. In the embedding, the meaning of a logic program arises compositionally from the meaning of its constituent subprograms and the combinators that connect them. In the second half of the thesis we explore applications of the embedding to the algebraic transformation of logic programs. A series of examples covers simple program derivations, where our techniques simplify some of the current techniques. Another set of examples explores applications of the more advanced program development techniques from the Algebra of Programming by Bird and de Moor [18], where we expand the techniques currently available for logic program derivation and optimisation. To my parents, Sandor and Erzsebet. And the end of all our exploring Will be to arrive where we started And know the place for the first time.

We present a functional DBPL in the style of FP that facilitates the definition of precise semantics and opens up opportunities for far-reaching optimizations. The language is integrated into a functional data model, which is extended by arbitrary type hierarchies and complex objects. Thus we are able to provide the clarity of FP-like programs together with the full power of semantic data modelling. To give an impression of the special facilities for optimizing functional database languages, we point out some laws not presented before which enable access path selection already on the algebraic level of optimization. The algebraic way of access path optimization also gives new insights into optimization strategies. 1 Introduction The design of new database programming languages is still a challenging task, for on the one hand it has to meet the conceptual requirements of programming languages and database systems at the same time, and on the other hand it has to present a suita...

L’algèbre relationnelle abstraite est utilisée pour donner une définition sémantique d’un langage de programmation impératif simple. A cet effet, divers domaines sont spécifiés par des axiomes relationnels. Certaines spécifications définissent des relations sur les types de base du langage (Booléens et entiers non négatifs); leur présentation insiste sur l’importance de la notion de point. Les autres spécifications construisent les domaines dont les relations sont utilisées pour dénoter les fragments de programmes. Les fragments ainsi traités sont les expressions, les déclarations de variables, les instructions (affectation, séquence, condition et itération) et les procédures. Les relations qui dénotent un frag-ment dépendent seulement de ce fragment et non de son environnement (à l’exception des procédures), ce qui constitue une approche originale. Enfin, on montre comment prouver la correction d’un fragment, relativement à une spécification, en utilisant sa définition sémantique. Les spécifications, la sémantique et la dérivation de programmes sont donc traitées uniformément dans le cadre de l’algèbre relationnelle abstraite. i Abstract relational algebra is used to define the semantics of a simple imperative language. In order to carry out this task, various domains are specified by relational axioms. Some specifications define relations on the basic types of the language (Booleans and natural numbers); their presentation stresses the importance of the concept of point. Other spec-ifications construct the relational domains whose relations are used to denote programs. The programming constructs that are defined include expressions, variable declarations, assignment statements, while-program statements and procedures. A particularity of the semantic definitions is that the relations denoting a program fragment depend only on the fragment, and not on its environment (procedure calls excepted). Finally, it is shown how the semantics of a program fragment can be used to prove its correctness relative to a specification. The result is a uniform abstract relational setting for specification, semantics and program derivation. ii

Relational program derivation has gathered momentum over the last decade with the development of many specification logics. However, before such relational specifications can be executed in existing programming languages, they must be carefully phrased to respect the evaluation order of the language. In turn, this requirement inhibits the rapid prototyping of specifications in a relational notation. The aim of this thesis is to bridge the gap between the methodology and practice of relational program derivation by realising a compositional style of logic programming that permits specifications to be phrased naturally and executed declaratively.

this article we describe a technique called grammar thinning that handles the elimination of redundant computation from programs. Grammar thinning is a technique that belongs with partial evaluation and supercompilation, as a powerful (and expensive) tool for general optimization and deep program transformation.

FL is the result of an e ort to design a practical functional programming language based on Backus' FP. This paper provides an introduction to and critique of the FL language. The language e ort is analyzed from several points of view: language design, implementation, and user experiences. Emphasis is placed on the unusual aspects of FL, its strengths and weaknesses, and how FL compares with other functional programming languages. 1