2 Instances

An instance is a compound data structure much like a record, except that it is defined by a class rather than a record type descriptor. Instances are more powerful than records, because their representation is designed to support inheritance, while the representation of records is not.

Procedure: instance-constructor class slot-names [n-init-args]

Creates and returns a procedure that, when called, will create and return a newly allocated instance of class.

Class must be a subclass of <instance>. Slot-names must be a list of symbols, each of which must be the name of a slot in class. N-init-args will be described below.

In its basic operation, instance-constructor works much like record-constructor: the slot-names argument specifies how many arguments the returned constructor accepts, and each of those arguments is stored in the corresponding slot of the returned instance. Any slots that are not specified in slot-names are given their initial values, as specified by the initial-value or initializer slot properties; otherwise they are left uninitialized.

After the new instance is created and its slots filled in, but before it is returned, it is passed to the generic procedure initialize-instance. Normally, initialize-instance does nothing, but because it is always called, the programmer can add methods to it to specify an initialization that is to be performed on every instance of the class.

By default, initialize-instance is called with one argument, the newly created instance. However, the optional argument n-init-args can be used to specify additional arguments that will be passed to initialize-instance.

The way this works is that the returned constructor procedure accepts additional arguments after the specified number of slot values, and passes these extra arguments to initialize-instance. When n-init-args is not supplied or is #t, any number of extra arguments are accepted and passed along. When n-init-args is an exact non-negative integer, exactly that number of extra arguments must be supplied when the constructor is called. Finally, if n-init-args is the symbol no-initialize-instance, then the constructor accepts no extra arguments and does not call initialize-instance at all; this is desirable when initialize-instance is not needed, because it makes the constructor significantly faster.

For notational convenience, n-init-args may take two other forms. First, it may be a list of symbols, which is equivalent to the integer that is the length of the list. Second, it may be the symbol no-init, which is an abbreviation for no-initialize-instance.

Note that the default method on initialize-instance accepts no extra arguments and does nothing.

Examples of instance-constructor:

(define-class <simple-reference> (<reference>)
  (from accessor reference-from)
  (to accessor reference-to)
  (cx accessor reference-cx)
  (cy accessor reference-cy))

(define make-simple-reference
  (instance-constructor <simple-reference>
                        '(from to cx cy)
                        'no-init))

(define-class <simple-wirenet> (<wirenet>)
  (cell accessor wirenet-cell)
  (wires accessor wirenet-wires
         modifier set-wirenet-wires!
         initial-value '()))

(define make-simple-wirenet
  (instance-constructor <simple-wirenet> '(cell)))

Procedure: instance? object

Returns #t if object is an instance, otherwise returns #f.

Procedure: instance-class instance

Returns the class of instance. This is faster than object-class, but it works only for instances, and not for other objects.

Procedure: instance-of? object specializer

Returns #t if object is a general instance of specializer, otherwise returns #f. This is equivalent to

(subclass? (object-class object) specializer)

Procedure: instance-predicate specializer

Returns a predicate procedure for specializer. The returned procedure accepts one argument and returns #t if the argument is an instance of specializer and #f otherwise.