Today's module systems do not effectively support information hiding in the presence of shared mutable objects, causing serious problems in the development and evolution of large software systems. Ownership types have been proposed as a solution to this problem, but current systems have ad-hoc access restrictions and are limited to Java-like languages.In this paper, we describe System F own, an extension of System F with references and ownership. Our design shows both how ownership fits into standard type theory and the encapsulation benefits it can provide in languages with first-class functions, abstract data types, and parametric polymorphism. By looking at ownership in the setting of System F, we were able to develop a design that is more principled and flexible than previous ownership type systems, while also providing stronger encapsulation guarantees.

Abadi et al. introduced the dependency core calculus (DCC) as a unifying framework to study many important program analyses such as binding time, information flow, slicing, and function call tracking. DCC uses a lattice of monads and a nonstandard typing rule for their associated bind operations to describe the dependency of computations in a program. Abadi et al. proved a noninterference theorem that establishes the correctness of DCC’s type system and thus the correctness of the type systems for the analyses above. In this paper, we study the relationship between DCC and the Girard-Reynolds polymorphic lambda calculus (System F). We encode the recursion-free fragment of DCC into F via a type-directed translation. Our main theoretical result is that, following from the correctness of the translation, the parametricity theorem for F implies the noninterference theorem for DCC. In addition, the translation provides insights into DCC’s type system and suggests implementation strategies of dependency calculi in polymorphic languages.

Reasoning about imperative programs requires the ability to track aliasing and ownership properties. We present a type system that provides this ability, by using regions, capabilities, and singleton types. It is designed for a high-level programming language with higher-order functions, algebraic data structures, and references (mutable memory cells). We then exhibit a type-directed translation of this imperative programming language into a purely functional language. Like the monadic translation, this is a store-passing translation. Here, however, the store is partitioned into multiple fragments, which are threaded through a computation only if they are relevant to it. Furthermore, the decomposition of the store into fragments can evolve dynamically to reflect ownership transfers. The translation offers deep insight about the inner workings and soundness of the type system. Furthermore, it provides a foundation for our long-term objective of designing a system for specifying and certifying imperative programs with dynamic memory allocation.

The type-and-e#ects system of the Tofte-Talpin region calculus makes it possible to safely reclaim objects without a garbage collector.

Abstract. We consider a type system capable of tracking reading, writing and allocation in a higher-order language with dynamically allocated references. We give a denotational semantics to this type system which allows us to validate a number of effect-dependent program equivalences in the sense of observational equivalence. An example is the following: x = e; y = e; e ′ (x, y) is equivalent to x = e; e ′ (x, x) provided that e does not read from memory regions that it writes to and moreover does not allocate memory that is encapsulated in the values of x and y. Here x can be a higher-order function or a reference or a combination of both. The two sides of the above equivalence turn out to be related in the denotational semantics which implies that they are observationally equivalent, ie can be replaced by one another in any (well-typed) program. On the way we learn popular techniques such as parametrised logical relations, regions, admissible relations, etc., which belong to the toolbox of researchers in principles of programming languages.

Monads serve the abstract encapsulation of side effects in semantics and functional programming. Various monad-based specification languages have been introduced in order to express requirements on generic side-effecting programs. A basic role is played here by global evaluation logic, concerned with formulae which may be thought of as being universally quantified over the state space; this formalism is the fundament of more advanced logics such as monad-based Hoare logic or dynamic logic. We prove completeness of global evaluation logic for models in cartesian categories with a distinguished Heyting algebra object.

Here is a pointer. Which memory blocks can it possibly point to? If I write through it, who will observe this effect? In fact, am I allowed to write through it? Does it point to a valid piece of memory? Who owns this piece of memory? This talk is not about original work of mine. It is an attempt to present a fraction of the many type systems that answer the above questions via notions of linearity, capabilities, or regions.

Static type systems have proved to be tremendously effective formal systems, making specification and verification sufficiently lightweight and intuitive that most programmers use them without even realizing it. Not only that, but they have shown to adapt very well to most modern language features. The downside is that the properties one can express and

Building on a judgmental formulation of lax logic, we propose a modal language which can be used as a framework for practical programming languages with e#ects. Its characteristic feature is a syntactic distinction between terms and expressions, where terms denote values and expressions denote computations. We distinguish between control e#ects and world e#ects, and allow control e#ects only in terms and world e#ects only in expressions. Therefore the distinction between values and computations is made only with respect to world e#ects. We give an explanation of the type system and the operational semantics from a modal logic perspective. We also introduce a term construct similar to Haskell's runST construct and augment the type system to ensure its safety.

Despite their invaluable contribution to the programming language community, monads as a foundation for the study of effects have three problems: they make it difficult to combine effects; they enforce sequentialization of computations by the syntax; they prohibit effect-free evaluations from invoking e#ectful computations. Building on the judgmental formulation and the possible worlds interpretation of modal logic, we propose a logical analysis of effects based upon the view monads are not identified with effects. Our analysis leads to a language called # # which distinguishes between control e#ects and world e#ects, enforces sequentialization of computations only by the semantics, and logically explains the invocation of computations from evaluations. # # also serves as a unified framework for studying Haskell and ML, which have traditionally been studied separately.