Store-passing style

Short description: Programming technique

Store-passing style is a programming technique that is used to model mutable state without using mutable state. It generally arises in the conversion of imperative programs into purely functional ones.

So, for instance, consider this JavaScript program, written in a non-store-passing-style:

var lastWasA = false

// a treebin represents a binary tree of strings.

// a treebin is either
// - a string, or
// - {l : <treebin>, r: <treebin>}

// does an in-order traversal of this tree's
// leaves contain an 'a' followed by a 'b'?
function aThenB(treebin) {
    if (typeof(treebin) === "string") {
        if (treebin === "a") {
            lastWasA = true;
            return false;
        } else if (treebin === "b") {
            if (lastWasA) {
                return true;
            } else {
                lastWasA = false;
                return false;
            }
        } else {
            lastWasA = false;
            return false;
        }
    } else { // not a string, must be an internal node:
        return ((aThenB(treebin.l))||(aThenB(treebin.r)));
    }
}

This contains a reference to a global variable. In store-passing style, the value of the global variable (or variables) is passed along to each call, and also returned from each call and threaded through the next call. The code might look like this:

function aThenB(treebin, lastWasA) {
    if (typeof(treebin) === "string") {
        if (treebin === "a") {
            return {result: false, lastWasA: true};
        } else if (treebin === "b") {
            if (lastWasA) {
                return {result: true, lastWasA: false};
            }
        } else {
            return {result: false, lastWasA: false};
        }
    } else { // not a string, must be an internal node:
        var leftCall = aThenB(treebin.l, lastWasA);
        if (leftCall.result) {
            return {result: true, lastWasA: false}
        } else {
            return aThenB(treebin.r, leftCall.lastWasA);
        }
    }
}

Note that each call takes an extra argument, and two values are now returned; the ordinary return value, and a new value representing the state of the formerly mutable variable.

Store-passing style can be quite painful to write, but can help to eliminate race conditions by isolating state within function calls, and can potentially make code more parallelizable.

See also

• Continuation-passing style