Monotonic References for Gradual Typing

We describe an alternative approach to handling mutable references (aka. pointers) within a gradually typed language that has different efficiency characteristics than the prior approach of Herman et al. [2010]. In particular, we hope to reduce the costs of reading and writing through references in statically typed regions of code. We would like the costs to be the same as they would in a statically typed language, that is, simply the cost of a load or store instruction (for primitive data types). This reduction in cost is especially important for programmers who would like to use gradual typing to facilitate transitioning from a dynamically-typed prototype of an algorithm to a statically-typed, high-performance implementation. The programmers we have in mind are scientists and engineers who currently prototype in Matlab and then manually translate their algorithms into Fortran. While our alternative approach succeeds in improving the efficiency of dereference and updates in statically typed code, it does come with some limitations. The approach requires all heap-allocated values to be tagged with their runtime type, which may be an added cost in space (though many languages require such tags for other reasons). In addition, our approach requires all values to be of a uniform size, which is true for many languages (most functional and object-oriented languages) but not true for some (the C family of languages). Finally, our approach is more restrictive than prior ones in that certain usage patterns are not allowed, triggering runtime exceptions, for which we give examples later in this introduction. The source of inefficiency in the prior approach of Herman et al. [2010], which we refer to as “guarded references”, is that two kinds of values have reference type: normal references and guarded references. A guarded reference consists of the underlying reference (a memory address) and two coercions, one to apply when reading and another to apply when writing. A guarded reference is created during runtime when a normal reference is casted from one reference type to another. When a compiler for a language