A Syntactic Model of Mutation and Aliasing

@inproceedings{Giannini2018ASM,
  title={A Syntactic Model of Mutation and Aliasing},
  author={Paola Giannini and Marco Servetto and Elena Zucca},
  booktitle={DCM/ITRS},
  year={2018}
}
Traditionally, semantic models of imperative languages use an auxiliary structure which mimics memory. In this way, ownership and other encapsulation properties need to be reconstructed from the graph structure of such global memory. We present an alternative "syntactic" model where memory is encoded as part of the program rather than as a separate resource. This means that execution can be modelled by just rewriting source code terms, as in semantic models for functional programs. Formally… 

Figures from this paper

Explicit and Controllable Assignment Semantics

This paper introduces Anzen, a programming language that aims to make assignments easier to understand and manipulate and offers three assignment operators, with unequivocal semantics, that can reproduce all common imperative assignment strategies.

Revisiting memory assignment semantics in imperative programming languages

This thesis developed a theoretical programming language to uniformly express the assignment semantics of imperative programming languages, and developed a general purpose programming language called Anzen, based on the theoretical foundation of the assignment calculus.

Featherweight Swift: a Core calculus for Swift’s type system

The foundations for a formal framework to reason about Swift's type system are laid, and Featherweight Swift, a minimal language stripped of all features not essential to describe its typing rules, is introduced.

References

SHOWING 1-10 OF 28 REFERENCES

An Imperative Pure Calculus

Tracing sharing in an imperative pure calculus: extended abstract

A type and effect system, for an imperative object calculus, which infers sharing possibly introduced by the evaluation of an expression, which is very expressive, and generalize notions introduced in literature by type modifiers.

Tracing sharing in an imperative pure calculus

The call-by-need lambda calculus

An equational characterization of the most popular lazy implementation technique – traditionally called ‘call-by-need’ – is developed and proved correct with respect to the original lambda calculus.

Effects and effect inference for a core Java calculus

Featherweight Java: a minimal core calculus for Java and GJ

This work extends Featherweight Java with generic classes in the style of GJ and gives a detailed proof of type safety, which formalizes for the first time some of the key features ofGJ.

Uniqueness and reference immutability for safe parallelism

This paper presents a type system to restrict the updates to memory to prevent these unintended side-effects of concurrent programming, and provides a novel combination of immutable and unique types that ensures safe parallelism and deterministic execution.

Region-based Memory Management

A region-based dynamic semantics for a skeletal programming language extracted from Standard ML is defined and the inference system which specifies where regions can be allocated and de-allocated is presented and a detailed proof that the system is sound with respect to a standard semantics is presented.

A type system for borrowing permissions

This work presents an integrated language and type system with unique, immutable, and shared permissions, together with new local permissions that say that a reference may not be stored to the heap, and presents the syntax and static and dynamic semantics of a formal core language and state soundness results.

A type and effect system for sharing

A type and effect system which infers sharing possibly introduced by the evaluation of an expression is outlined, which gets very expressive types, which generalize notions enforced in literature by type modifiers.