Scope (programming)
|
|
In computer programming in general, a scope is an enclosing context. Scopes have contents which are associated with them. Various programming languages have various types of scopes. The type of scope determines what kind of entities it can contain and how it affects them. Depending on its type, a scope can:
- contain declarations or definitions of identifiers;
- contain statements and/or expressions which define an executable algorithm or part thereof;
- nest or be nested.
A namespace is a scope that uses the enclosing nature of the scope to group logically related identifiers under a single identifier. Thus, scopes can affect the name resolution for their contents.
In compiled languages, scopes are strictly compile time entities. Scopes are used to define and structure various program entities, but a compiled program is completely unaware of scope.
Variables are associated with scopes. See variables (scope and extent). Different scoping types affect how local variables are bound, see static versus dynamic scoping.
Programmers often indent scopes in their source code text to improve readability.
| Contents |
Example scopes
namespace { // namespace scope, merely groups identifiers
class C { // class scope, defines/declares member variables and functions
void f (bool b) { // function scope, contains executable statements
if (b) { // unnamed scope for conditionally executed statements
...
}
}
};
}
(Note that this example merely illustrates basic scoping ideas, it is not meant as a formal complete description of what the various C++ scopes can contain.)
Static versus dynamic scoping
One of the basic reasons for scoping is to keep variables in different parts of the program distinct from one another. Since there are only a small number of short variable names, and programmers share habits about the naming of variables (i for an array index, etc.), in any program of moderate size the same variable name will be used in multiple different scopes. The question of how to match various variable occurrences to the appropriate binding sites is generally answered in one of two ways: static scoping and dynamic scoping.
Static scoping
With static scoping, a variable always refers to its nearest enclosing binding. This is a property of the program text and unrelated to the runtime call stack. Because matching a variable to its binding only requires analysis of the program text, this type of scoping is sometimes also called lexical scoping. Static scope is standard in modern functional languages such as ML and Haskell because it allows the programmer to reason as if variable bindings are carried out by substitution. Static scoping also makes it much easier to make modular code and reason about it, since its binding structure can be understood in isolation. In contrast, dynamic scope forces the programmer to anticipate all possible dynamic contexts in which his module's code may be invoked.
Correct implementation of static scope in languages with first-class nested functions can be subtle, as it requires each function value to carry with it a record of the values of the variables that it depends on (the pair of the function and this environment is called a closure). When first-class nested functions are not used or not available (such as in C), this overhead is of course not incurred. Variable lookup is always very efficient with static scope; the location of the each value is known at compile time.
Dynamic scoping
In dynamic scoping, each identifier has a global stack of bindings. Introducing a local variable with name x pushes a binding onto the global x stack (which may have been empty), which is popped off when the control flow leaves the scope. Evaluating x in any context always yields the top binding. Note that this cannot be done at compile time because the binding stack only exists at runtime, which is why this type of scoping is called dynamic scoping.
Generally certain blocks are defined to create bindings whose lifetime is the execution time of the block; this adds a hint of lexicality to the scoping. However, since a section of code can be called from many different locations and situations, it can be difficult to determine at the outset what bindings will apply when a variable is used. This can be beneficial; application of the principle of least knowledge suggests that code avoid depending on the reasons for (or circumstances of) a variable's value, but simply use the value according to the variable's definition. This narrow interpretation of shared data can provide a very flexible system for adapting the behavior of a function to the current state (or policy) of the system. However, this benefit relies on careful documentation of all variables used this way as well as on careful avoidance of assumptions about a variable's behavior, and does not provide any mechanism to detect interference between different parts of a program. As such, dynamic scoping can be dangerous and many modern languages do not use it. Some languages, like Perl and Common Lisp, allow the programmer to choose lexical or dynamic scoping when (re)defining a variable.
Implementation
Dynamic scoping is extremely simple to implement. To find an identifier's value, the program traverses the runtime stack, checking each activation record (each function's stack frame) for a value for the identifier. This is known as deep binding. An alternate strategy that is usually more efficient is to maintain a stack of bindings for each identifier; the stack is modified whenver the variable is bound or unbound, and a variable's value is simply that of the top binding on the stack. This is called shallow binding. Note that both of these strategies assume a LIFO ordering to bindings for any one variable; in practice all bindings are so ordered.
Example
int x = 0;
int f () { return x; }
int g () { int x = 1; return f(); }
With static scoping, calling g will return 0 since it has been determined at compile time that the expression x in any invocation of f will yield the global x binding which is unaffected by the introduction of a local variable of the same name in g.
With dynamic scoping, the binding stack for the x identifier will contain two items when f is invoked: the global binding to 0, and the binding to 1 introduced in g (which is still present on the stack since the control flow hasn't left g yet). Since evaluating the identifier expression by definition always yields the top binding, the result is 1.
History
Lexical scoping was first introduced in Algol, and has been picked up in other languages since then. Descendants of dynamically scoped languages often adopt lexical scoping. In Lisp, for example, Emacs Lisp once used only dynamic scoping, Common Lisp has both dynamic and lexical scoping, and Scheme uses lexical scoping exclusively. The original Lisp used dynamic scoping. In other cases, languages which already had dynamic scoping have added lexical scoping afterwards, such as Perl. C and Pascal have always had lexical scoping, since they are both influenced by the ideas that went into Algol.