Nested function

From Wikipedia, the free encyclopedia

In computer programming, a nested function (or nested procedure/subroutine) is a function which is lexically (textually) encapsulated within another function. It can only be called by the enclosing function or by functions directly or indirectly nested within the same enclosing function. In other words, the scope of the nested function is limited by the enclosing function. The nesting is theoretically possible to any level of depth, although only a few levels are normally used in practice.

1 An example
2 Purpose
3 Languages
- 3.1 Functional languages
4 Implementation
5 See also
6 References

[edit] An example

An example using Pascal syntax:

function E(x: real): real

    function F(y: real): real
    begin
        F := x + y
    end

begin
    E := F(3)
end

and the same example in a C-like syntax:

float E(float x)
{
    float F(float y)
    {
        return x + y;
    }
    return F(3);
}

The function F is nested within E (note that x is visible in F, while y is invisible outside F).

[edit] Purpose

Nested functions are a form of information hiding and are useful for dividing procedural tasks into subtasks which are only meaningful locally; it avoids cluttering other parts of the program with functions, variables, etc. unrelated to those parts. Nested functions therefore complements other structuring possibilities such as records and objects.

In languages with nested functions, functions may normally also contain local constants, and types (in addition to local variables, parameters, and functions), encapsulated and hidden in the same nested manner. This may further enhance the code structuring possibilites.

[edit] Languages

Well known languages supporting lexically nested functions include:

Algol-based languages such as Algol68, Simula, Pascal, Modula2, and Ada
Modern versions of Lisp (with lexical scope) such as Scheme, and Common Lisp
Scripting languages, such as Ruby, Python, Perl 6 (support to various degrees), JavaScript, and ActionScript
There is also a C-related language with nested functions, the D language.
GCC also supports nested functions in C, although the C standard does not specify support for nested funtions. ^[1]

[edit] Functional languages

In Scheme and most other functional programming languages, nested functions are a common way of implementing algorithms with loops in them. A simple (tail) recursive inner function is created, which behaves as the algorithm's main loop, while the outer function performs startup actions that only need to be done once. In more complex cases, a number of mutually recursive functions may be created as inner functions.

[edit] Implementation

There are several ways to implement nested procedures, but the classic way is as follows:

Any non-local object, X, is reached via access-links in the activation frames on the machine stack. The caller, C, assists the called procedure, P, by pushing a direct link to the latest activation of P's immediate lexical encapsulation, (P), prior to the call itself. P may then quickly find the right activation for a certain X by following a fixed number (P.depth - X.depth) of links (normally a small number).

The caller creates this direct link by (itself) following C.depth - P.depth + 1 older links, leading up to the latest activation of (P), and then temporarily bridging over these with a direct link to that activation; the link later disappears together with P, whereby the older links beneath it, may come into use again.

Note that P is visible for, and may therefore be called by, C if (P) = C / (C) / ((C)) / etc.

This original method is faster than it may seem, but it is nevertheless often optimized in practical compilers (using displays or similar techniques).