An important application of unique object references is safe and efficient message passing in concurrent object-oriented programming. However, to prevent the ill effects of aliasing, practical systems often severely restrict the shape of messages passed by reference. Moreover, the problematic interplay between destructive reads--often used to implement unique references--and temporary aliasing through ``borrowed'' references is exacerbated in a concurrent setting, increasing the potential for unpredictable run-time errors.
This paper introduces a new approach to uniqueness. The idea is to use capabilities for enforcing both at-most-once consumption of unique references, and a flexible notion of uniqueness. The main novelty of our approach is a model of uniqueness and borrowing based on simple, unstructured capabilities. The advantages are: first, it provides simple foundations for uniqueness and borrowing. Second, it can be formalized using a relatively simple type system, for which we provide a complete soundness proof. Third, it avoids common problems involving borrowing and destructive reads, since unique references subsume borrowed references.
We have implemented our type system as an extension to Scala. Practical experience suggests that our system allows type checking real-world actor-based concurrent programs with only a small number of additional type annotations.
A prototype implementation of the type checker as a plugin for the EPFL Scala compiler is available in the Scala SVN repository. The sources include all examples discussed in the above report.
scala-unique branch from the Scala
SVN [Scala
Trac Viewer]:
svn co https://lampsvn.epfl.ch/svn-repos/scala/scala/branches/scala-unique