Tu banner alternativo

Store-passing style

In today's world, Store-passing style is a topic that has captured the attention of people of all ages and backgrounds. Whether due to its impact on society, its relevance in the professional field or its influence on popular culture, Store-passing style has positioned itself as a topic of general interest that generates all types of opinions and debates. From its origin to its possible consequences, Store-passing style has aroused the interest of academics, activists, opinion leaders and the general public, becoming an object of study and countless discussions. In this article, we will explore different aspects related to Store-passing style and its importance in today's world.

Tu banner alternativo

Store-passing style is a programming technique that is used to model mutable state without using mutable state.[1][2] 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

References

  1. ^ Friedman, Daniel; Wand, Mitchell (April 2008). Essentials of Programming Languages (3rd ed.). Boston, MA: MIT Press. ISBN 978-0262062794.
  2. ^ Krishnamurthi, Shriram (November 2012). Programming Languages, Application and Interpretation (2nd ed.). self-published. Retrieved 10 February 2016.
Wikious
Boobota
Sagapedia