Objects are elementary building blocks. TOM's notion of objects is obviously inspired by Smalltalk, in that for every defined class, a class object, or factory object as it is sometimes called, exists. A class object describes the state (instance variables or member variables) and behaviour (instance methods or member functions) of its instances. Conceptually, each class object is the sole instance of its meta class object, the meta class object describing the state and behaviour of the class object. All meta class objects share the same meta-meta class object.
Classes and instances are distinct entities. A class of objects is only fully defined by both the definition of the class and the definition of the instances.
It is possible for instances not to carry any state; such instances can not actually be allocated, but their definition can be inherited by other objects, even class objects. A class with stateless instance is a behavioural class.
All classes with allocatable instances must inherit, directly or
indirectly, from the
State class: It is the
that defines the instance and class variables necessary for the runtime
system to function. Most notably, the
State instance introduces
isa instance variable. For every instance, this variable
points to the class object describing the instance.
A class or instance definition can declare methods to be deferred. A class having deferred methods, either because of its own definition or because of inheritance, is said to be a deferred class. Instances of a deferred class can not be allocated; only instances of a subclass which actually defines all deferred methods can be allocated.
A behavioural instance with only deferred methods (i.e. without providing any method implementation) resembles an Objective-C protocol, a Java interface, and a C++ signature. There are, however, elementary differences
A class can pose as another class. A posing class is inserted into the class hierarchy between the posed class and any subclass or client: all references to the posed class actually refer to the posing class (except for references from the posing class itself). Posing is especially useful in the context of library units over which the programmer has no source control.
With the semantics of extensions, posing might seem a bit too much like using a canon to shoot a mosquito. All posing really adds is the ability to override methods while still being able to refer to the original. The real advantage of posing is that referring to the original method implementation is as simple as messaging super.
tom.Stateclass object for its ability to describe instances. This implicit inheritance is excluded from the above fact.)
tom.Statemeta class object serves as the meta-meta class object.
class_name: IDENTIFIER | unit_name `.' IDENTIFIER ;
A class name is either an identifier, or an identifier qualified by the name of the unit in which it is defined (see section Units for an explanation of units).
An unqualified class name must refer to the only class name visible or
it is an error. A class
Foo in some unit
classes by the same name, in units upon which the unit
The type of instances of a class is denoted as the
Shifted in the direction of the
class make it denote the class
/* my_foo references an instance of Foo or an instance of a subclass. */ Foo my_foo; /* foo_class references the Foo class or a subclass thereof. */ class (Foo) foo_class;
Go to the first, previous, next, last section, table of contents.