Abstract not found

Refinement types allow many more properties of programs to be expressed and statically checked than conventional type systems. We present a practical algorithm for refinement-type checking in a -calculus enriched with refinement-type annotations. We prove that our basic algorithm is sound and complete, and show that every term which has a refinement type can be annotated as required by our algorithm. Our positive experience with an implementation of an extension of this algorithm to the full core language of Standard ML demonstrates that refinement types can be a practical program development tool in a realistic programming language. The required refinement type definitions and annotations are not much of a burden and serve as formal, machine-checked explanations of code invariants which otherwise would remain implicit. 1 Introduction The advantages of statically-typed programming languages are well known, and have been described many times (e.g. see [Car97]). However, conventional ty...

This paper unveils and motivates an ambitious programme of hidden algebraic research in software engineering, beginning with our general goals, continuing with an overview of results, and including some future plans. The main contribution is powerful hidden coinduction techniques for proving behavioral correctness of concurrent systems; several mechanical proofs are given using OBJ3. We also show how modularization, bisimulation, transition systems, concurrency and combinations of the functional, constraint, logic and object paradigms fit into hidden algebra. 1. Introduction

This paper presents an (abstract) model theoretic semantics for ECLP, without directly addressing the computational aspect. This is a rather novel approach on the area of constraints where almost all efforts have been devoted to computational and operational issues; it is important the reader understands the model-theoretic and foundational orientation of this paper. However, we plan to gradually develop the computational side based on these foundations as further research (Section 7.2 sketches some of the directions of such further research). Some computational aspects of this theory can already be found in (Diaconescu, 1996c). This semantics is

Software development is a complex and error prone task. Programming languages with strong static type systems assist programmers by capturing and checking the fundamental structure of programs in a very intuitive way. Given this success, it is natural to ask: can we capture and check more of the structure of programs? In this work I consider a new approach called refinement-type checking that allows many common program properties to be captured and checked. This approach builds on the strength of the type system of a language by adding the ability to specify refinements of each type. Such refinement types have been considered previously, and following previous work I focus on refinements that include subtyping and a form of intersection types. Central to my approach is the use of a bidirectional checking algorithm. This does not attempt to infer refinements for some expressions, such as functions, but only checks them against refinements. This avoids some difficulties encountered in previous work, and requires that the programmer annotate their program with some of the intended refinements, but the required annotations appear to be very reasonable. Further, they document properties in a way that is natural, precise, easy to read, and reliable. I demonstrate the practicality of my approach by showing that it can be used to design a refinement-type checker for a widely-used language with a strong type system: Standard ML. This requires two main technical developments. Firstly, I present a new variant of intersection types that achieve soundness in the presence of call-by-value effects by incorporating a value restriction. Secondly, I present a practical approach to incorporating recursive refinements of ML datatypes, including a pragmatic method for checking the sequential pattern matching construct of ML. I also report the results of experiments with my implementation of refinement-type checking for SML. These indicate that refinement-type checking is a practical method for capturing and checking properties of real code.

System F ! is an extension of system F ! with subtyping and bounded quantification. Order-sorted algebra is an extension of many-sorted algebra with overloading and subtyping. We combine both formalisms to obtain IF ! , a higher-order typed -calculus with subtyping, bounded quantification and order-sorted inductive types, i.e. data types with built-in subtyping and overloading. Moreover we show that IF ! enjoys important meta-theoretic properties, including confluence, strong normalization, subject reduction and decidability of type-checking. 1 Introduction Typed functional programming languages such as Haskell and ML and typetheory based proof-development systems such as Coq and Lego support the introduction of inductively defined types such as natural numbers or booleans, parameterized inductively defined types such as lists and even parameterized mutual inductively defined types such as trees and forests. In addition, those languages support the definition of functions ...

The first topic of the paper is to provide a formalization of the principle of compositionality of meaning. A mathematical model (based upon universal algebra) is presented, and its properties are investigated. The second topic is to discuss arguments from the literature against compositionality (of Hintikka, Higginbotham, Pelletier, Partee, Schiffer and others). Methods are presented that help to obtain compositionality. It is argued that the principle is should not be considered an empirical verifyable restriction, but a methodological principle that describes how a system for syntax and semantics should be designed. The paper has an appendix by B. Partee on the compositional treatment of genitives.

The feature interaction problem is prominent in telephone service development. Through a number of case studies, we have discovered that no single semantic framework is suitable for the synthesis and analysis of formal feature requirements models, and the choice of modelling language has certain knock-on effects on the transformational design steps which lead to implementation.

Heterogeneous multi-logic theories arise in different contexts: they are needed for the specification of large software systems, as well as for mediating between different

. We show that a suitable abstraction of the notion of termalgebra, called compositum, can be used to capture in a precise mathematical way the intuition that the category of algebras of most (order-sorted) equational theories is completely characterised by their term-model. We also use the relationship between composita and order-sorted equational theories to show that every order-sorted compositum can be canonically embedded into an unsorted one. 1 Introduction The interplay between syntax and semantics plays a fundamental role in the theory of algebraic specifications. On the one hand, syntax can be used to describe and study syntax-free structures, such as data structures, see [6, 7]. On the other hand, the fundamental nature of syntactic concepts such as unification or term-rewriting is often better understood when presented in an abstract, syntax-free framework (such as monads, algebraic theories or composita), see [5, 10, 12, 14]. In both cases, the switch between the two persp...