Instance Variables

Each instance-variable-clause has one of these forms:

 
   (simple-variable-specifier instance-var-declaration   ) 
   (directed-variable-specifier superclass-name instance-var-declaration   ) 
   (sequence expression   ) 

A  sequence clause does not define any instance variables. It only specifies expressions to be evaluated in order at initialization time.

simple-variable-specifiers and directed-variable-specifiers are keyword variable specifiers. They are used in variable declaration clauses to define the properties of instance variables:

• Visibility -- Each instance variable is either private or public. A private variable can only be used within the class definition; a public variable can be accessed from derived classes and from outside the object, and can be overridden in a derived class. When a public variable is overridden, the original value can still be accessed.
• Generation -- Each instance variable declaration is either a new value definition or a reference to an existing variable in a superclass.
• Binding -- An instance variable declaration can override declarations in the superclasses, or provide only a local value. Private instance variable declarations can never override superclass declarations. Public variable access from outside the object (i.e., using ivar) cannot distinguish between local and overriding declarations; the distinction affects only the superclasses, in which an overriding declaration redirects references and a local declaration does not.

Figure 2.1 shows how combinations of the above properties are specified with different variable specifier keyword.

A simple-variable-specifier is one of:  

• public   -- These instance variables are fully visible. A derived class can override public declarations, and public declarations override existing declarations in the superclass(es).
• private   -- These instance variables can be accessed only within the class definition. They cannot be overridden in a derived class and do not override declarations in the superclass(es).
• local   -- Like public, but declarations in the superclass(es) are not overridden.
• inherit   -- Declares public instance variables that must be defined in one of the superclasses. If the specified variable name is declared in multiple superclasses, a single declaration is selected by the search path described in section 2.13.6. No variables in the superclasses are overridden by an inherit declaration, but an inherit declaration can be overridden.
• rename   -- Similar to inherit, but a new name is used to access the value locally. This new name can only be used within the class definition. A rename declaration accesses the superclass-defined variable value, even if that value is overridden.
• share   -- Like rename, but the new name is publicly accessible. Existing declarations in superclasses using the new variable name are overridden by the referenced declaration.

A directed-variable-specifier is either inherit-from, rename-from, or share-from; these specifiers are refinements of inherit, rename, and share, respectively, where the search path for the inherited instance variable is narrowed to a single superclass.

There can be multiple clauses with the same variable specifier, and different variable specifiers clauses can be declared in any order.

In public, private, and local clauses, each instance-var-declaration has one of the following forms:  

 
   (instance-var-name instance-var-initial-value)
   (instance-var-name)
   instance-var-name 

Each instance-var-name must be an identifier and each instance-var-initial-value is an expression. The scoping rules for the initial value expressions are described below. When an initial value expression is not given, (void) is assumed. An instance variable name can be declared only once within a class definition.

In inherit and inherit-from clauses, each instance-var-declaration is just an identifier that is used as the name of the variable that is inherited.

In rename, share, rename-from, and share-from clauses, each instance-var-declaration has the form:

 
  (instance-var-name inherited-name) 

Both instance-var-name and inherited-name must be an identifier. instance-var-name is the new variable name, and inherited-name is the name of the variable that is inherited.

Inheritance is verified at class-creation time. If an inherited instance variable is not found in the superclass(es), the  exn:object:inherit exception is raised.

  
Figure 2.1: Variable specifier summary