Name binding

Binding time

• Static binding (or early binding) is name binding performed before the program is run.^[2]
• Dynamic binding (or late binding or virtual binding) is name binding performed as the program is running.^[2]

An example of a static binding is a direct C function call: the function referenced by the identifier cannot change at runtime.

But an example of dynamic binding is dynamic dispatch, as in a C++ virtual method call. Since the specific type of a polymorphic object is not known before runtime (in general), the executed function is dynamically bound. Take, for example, the following Java code:

public void foo(java.util.List<String> list) {
    list.add("bar");
}

List is an interface, so list must refer to a subtype of it. Is it a reference to a LinkedList, an ArrayList, or some other subtype of List? The actual method referenced by add is not known until runtime. In C, such an instance of dynamic binding may be a call to a function pointed to by a variable or expression of a function pointer type whose value is unknown until it actually gets evaluated at run-time.

Rebinding and mutation

Rebinding should not be confused with mutation.

• Rebinding is a change to the referencing identifier.
• Mutation is a change to the referenced entity.

Consider the following Java code:

LinkedList<String> list;
list = new LinkedList<String>();
list.add("foo");
list = null;

The identifier list initially references nothing (it is uninitialized); it is then rebound to reference an object (a linked list of strings). The linked list referenced by list is then mutated, adding a string to the list. Lastly, list is rebound to null.

Late static

Late static binding is a variant of binding somewhere between static and dynamic binding. Consider the following PHP example:

class A
{
    public static $word = "hello";
    public static function hello() { print self::$word; }
}

class B extends A
{
    public static $word = "bye";
}

B::hello();

In this example, the PHP interpreter binds the keyword self inside A::hello() to class A, and so the call to B::hello() produces the string "hello". If the semantics of self::$word had been based on late static binding, then the result would have been "bye".

Beginning with PHP version 5.3, late static binding is supported.^[3] Specifically, if self::$word in the above were changed to static::$word as shown in the following block, where the keyword static would only be bound at runtime, then the result of the call to B::hello() would be "bye":

class A
{
    public static $word = "hello";
    public static function hello() { print static::$word; }
}

class B extends A
{
    public static $word = "bye";
}

B::hello();

See also

• Late binding
• Branch table method of applying name binding via branch table or function pointers
• Dynamic dispatch
• Higher-order abstract syntax (HOAS)

References