Dynamic rebinding for marshalling and update, via redex-time and destruct-time reduction

Abstract

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example, when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically, it is provided only by ad hoc mechanisms that lack clean semantics. In this paper, we adopt a foundational approach, developing core dynamic rebinding mechanisms as extensions to the simply typed call-byvalue λ calculus. To do so, we must first explore refinements of the call-by-value reduction strategy that delay instantiation, to ensure computations make use of the most recent versions of rebound definitions. We introduce redex-time and destruct-time strategies. The latter forms the basis for a λ marsh calculus that supports dynamic rebinding of marshalled values, while remaining as far as possible statically typed. We sketch an extension of λ marsh with concurrency and communication, giving examples showing how wrappers for encapsulating untrusted code can be expressed. Finally, we show that a high-level semantics for dynamic updating can also be based on the destruct-time strategy, defining a λ update calculus with simple primitives to provide type-safe updating of running code. We show how the ideas of this simple calculus extend to more real-world, module-level dynamic updating in the style of Erlang. We thereby establish primitives and a common semantic foundation for a variety of real-world dynamic rebinding requirements.

ReCaml

“…As a side-effect, the env operator also ensures that continuations are independent of any evaluation environment, i.e., any continuation brings its required environment in an env construct. To some extent, this is similar to the destructtime λ-calculus [8,33], which delays substitutions until values are consumed. That way, bindings can be marshalled and move between scopes.…”

Compilation of extended recursion in call-by-value functional languages

“…This strategy w.r.t. substitution, called destruct-time by Sewell et al [28], does not contradict the fact that λ • is call-by-value. Indeed, only values are copied, and any expression reached by the evaluation is immediately evaluated.…”

“…We start with small examples to give some intuition on the semantics. First, as noted in Remark 2, substitution occurs at destruct-time in λ • , following the terminology of [28]. This means that substitution of an occurrence of a variable is only performed when this occurrence has to be replaced with a non-variable value in order for the evaluation to continue.…”

Formalizing consistent dynamic updates for component-based software

“…But we believe a formal and mathematical model of dynamic update should be developed in order to understand what design choices can be considered in a component-based system. There a few formalization works have been carried out to support the correctness and consistency derivations of dynamic update [6], [7], [8], [9]. Nevertheless, we are not aware of past efforts that have well formalized the aspects for timing of update, state transformation and update failure recovery.…”