The essence of functional programming
POPL '92 Proceedings of the 19th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Region-based memory management
Information and Computation
Rolling your own mutable ADT—a connection between linear types and monads
Proceedings of the 24th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Coinductive axiomatization of recursive type equality and subtyping
Fundamenta Informaticae - Special issue: typed lambda-calculi and applications, selected papers
Typed memory management in a calculus of capabilities
Proceedings of the 26th ACM SIGPLAN-SIGACT symposium on Principles of programming languages
From Algol to polymorphic linear lambda-calculus
Journal of the ACM (JACM)
Types and programming languages
Types and programming languages
Adoption and focus: practical linear types for imperative programming
PLDI '02 Proceedings of the ACM SIGPLAN 2002 Conference on Programming language design and implementation
Separation Logic: A Logic for Shared Mutable Data Structures
LICS '02 Proceedings of the 17th Annual IEEE Symposium on Logic in Computer Science
Alias Types for Recursive Data Structures
TIC '00 Selected papers from the Third International Workshop on Types in Compilation
Verification of non-functional programs using interpretations in type theory
Journal of Functional Programming
Connecting effects and uniqueness with adoption
Proceedings of the 32nd ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Journal of Functional Programming
L3: A Linear Language with Locations
Fundamenta Informaticae - Typed Lambda Calculi and Applications 2005, Selected Papers
Abstract predicates and mutable adts in hoare type theory
ESOP'07 Proceedings of the 16th European conference on Programming
The Why/Krakatoa/Caduceus platform for deductive program verification
CAV'07 Proceedings of the 19th international conference on Computer aided verification
Safe programming with pointers through stateful views
PADL'05 Proceedings of the 7th international conference on Practical Aspects of Declarative Languages
Linear regions are all you need
ESOP'06 Proceedings of the 15th European conference on Programming Languages and Systems
Effective interactive proofs for higher-order imperative programs
Proceedings of the 14th ACM SIGPLAN international conference on Functional programming
Who: a verifier for effectful higher-order programs
Proceedings of the 2009 ACM SIGPLAN workshop on ML
Lightweight linear types in system f°
Proceedings of the 5th ACM SIGPLAN workshop on Types in language design and implementation
Lolliproc: to concurrency from classical linear logic via curry-howard and control
Proceedings of the 15th ACM SIGPLAN international conference on Functional programming
Capabilities for uniqueness and borrowing
ECOOP'10 Proceedings of the 24th European conference on Object-oriented programming
Step-indexed kripke models over recursive worlds
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
A typed store-passing translation for general references
Proceedings of the 38th annual ACM SIGPLAN-SIGACT symposium on Principles of programming languages
Proceedings of the 5th ACM workshop on Programming languages meets program verification
The essence of monotonic state
Proceedings of the 7th ACM SIGPLAN workshop on Types in language design and implementation
FOSSACS'11/ETAPS'11 Proceedings of the 14th international conference on Foundations of software science and computational structures: part of the joint European conferences on theory and practice of software
Proceedings of the ACM SIGPLAN 2014 Workshop on Programming Languages meets Program Verification
Hi-index | 0.00 |
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 calculus with higher-order functions, algebraic data structures, and references (mutable memory cells). The type system has polymorphism, yet does not require a value restriction, because capabilities act as explicit store typings. We exhibit a type-directed, type-preserving, and meaning-preserving translation of this imperative calculus into a pure calculus. 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. If coupled with a semantic model of its target calculus, it leads to a semantic model of its imperative source calculus. Furthermore, it provides a foundation for our long-term objective of designing a system for specifying and certifying imperative programs with dynamic memory allocation.