Guaranteeing safe destructive updates through a type system with uniqueness information for graphs

Smetsers, Sjaak; Barendsen, Erik; Eekelen, M.C.J.D. van; Plasmeijer, M.J.

doi:10.1007/3-540-57787-4_23

Cited by 25 publications

(19 citation statements)

References 4 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…Furthermore, he proposes that a value that represents "the file system" should be assigned a linear type. In the same manner, Clean uses uniqueness types to ensure that the "world" is never duplicated [Smetsers et al 1994;Achten and Plasmeijer 1995]. The early linear type systems are often very restrictive, though.…”

Section: Containers Ownership and Ownership Transfermentioning

confidence: 99%

The Design and Formalization of Mezzo, a Permission-Based Programming Language

Balabonski

Pottier

Protzenko

2016

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

The programming language Mezzo is equipped with a rich type system that controls aliasing and access to mutable memory. We give a comprehensive tutorial overview of the language. Then, we present a modular formalization of Mezzo's core type system, in the form of a concurrent λ-calculus, which we successively extend with references, locks, and adoption and abandon, a novel mechanism that marries Mezzo's static ownership discipline with dynamic ownership tests. We prove that well-typed programs do not go wrong and are data-race free. Our definitions and proofs are machine-checked. XXXX:2 T. Balabonski et al. 1 open woref 2 3 val f (x: frozen int , y: frozen int) : int = 4 get x + get y 5 6 val _ : int = 7 let r = new () in 8 set (r, 3); 9 f (r, r) Fig. 1. Using a write-once ref-erence. The Mezzo type system guarantees that the user must call set before using get, and can call set at most once. and robustness; in return, they offer far greater expressiveness than a simple-minded, purely static discipline could hope to achieve.In this paper, we offer a comprehensive overview of Mezzo, including an informal, user-level presentation of the language and a formal, machine-checked presentation of its meta-theory. This unifies and subsumes the two conference papers cited above. Furthermore, we revisit the theory of adoption and abandon, which was presented informally in the first conference paper, and was absent from the second conference paper. Our new account of adoption and abandon is not only machine-checked, but also simpler and more expressive than that of the conference paper. A few examplesWe begin with two short illustrative examples. The first one concerns a type of writeonce references and shows how Mezzo guarantees that the client follows the intended usage protocol. The second example is a racy program, which the type system rejects. We show how to fix this ill-typed program by introducing a lock.A usage protocol. A write-once reference is a memory cell that can be assigned at most once and cannot be read before it has been initialized. Fig. 1 shows some client code that manipulates a write-once reference. The code refers to the module woref, whose implementation we show later on ( §2.1).At line 7, we create a write-once reference by calling woref::new. (Thanks to the declaration open woref, one can refer to this function by the unqualified name new.) The local variable r denotes the address of this reference. In the eyes of the typechecker, this gives rise to a permission, written r @ writable. This permission has a double reading: it describes the layout of memory (i.e., "the variable r denotes the address of an uninitialized memory cell") and grants exclusive write access to this memory cell. That is, the type constructor writable denotes a uniquely-owned writable reference, and the permission r @ writable is a unique token that one must possess in order to write r.Permissions are tokens that exist at type-checking time only. Many permissions have the form x @ t, where x is a program variable and t is a ty...

show abstract

Section: Containers Ownership and Ownership Transfermentioning

confidence: 99%

The Design and Formalization of Mezzo, a Permission-Based Programming Language

Balabonski

Pottier

Protzenko

2016

ACM Trans. Program. Lang. Syst.

View full text Add to dashboard Cite

show abstract

“…Linear type systems. Starting with Wadler [17], linear types systems have been used in purely functional languages to enforce single threading on the state of the world or to implement operations like array updating without the cost of a full copy [12]. Linear type systems enable resource management at the granularity of a single object.…”

Section: Related Workmentioning

confidence: 99%

Adoption and focus

FähndrichManuel

DeLineRobert

2002

SIGPLAN Not.

View full text Add to dashboard Cite

A type system with linearity is useful for checking software protocols and resource management at compile time. Linearity provides powerful reasoning about state changes, but at the price of restrictions on aliasing. The hard division between linear and nonlinear types forces the programmer to make a trade-off between checking a protocol on an object and aliasing the object. Most onerous is the restriction that any type with a linear component must itself be linear. Because of this, checking a protocol on an object imposes aliasing restrictions on any data structure that directly or indirectly points to the object. We propose a new type system that reduces these restrictions with the adoption and focus constructs. Adoption safely allows a programmer to alias objects on which she is checking protocols, and focus allows the reverse. A programmer can alias data structures that point to linear objects and use focus for safe access to those objects. We discuss how we implemented these ideas in the Vault programming language.

show abstract

“…The two most promising approaches are based on monads [8] or on unique types [9]. Both approaches ultimately use the type system to guarantee that a data structure is single threaded, and that destructive updates are therefore safe.…”

Section: Is O(n)mentioning

confidence: 99%

Experiments with destructive updates in a lazy functional language

Hartel

Vree

1994

Computer Languages

View full text Add to dashboard Cite

Abstract--The aggregate update problem has received considerable attention since pure functional programming languages were recognised as an interesting research topic. There is extensive literature in this area, which proposes a wide variety of solutions. We have tried to apply some of the proposed solutions to our own applications to see how these solutions work in practice. We have been able to use destructive updates but are not convinced that this could have been achieved without application specific knowledge. In particular, no form of update analysis has been reported that is applicable to non-fiat domains in polymorphic languages with higher order functions.

show abstract

Guaranteeing safe destructive updates through a type system with uniqueness information for graphs

Cited by 25 publications

References 4 publications

The Design and Formalization of Mezzo, a Permission-Based Programming Language

The Design and Formalization of Mezzo, a Permission-Based Programming Language

Adoption and focus

Experiments with destructive updates in a lazy functional language

Contact Info

Product

Resources

About