Normal selector invocations determine the method at run-time depending on the class of the receiving object (late binding).
Sometimes we want to invoke a different method. E.g., assume that
you want to use the simple method for
objects instead of the possibly long-winded
[bind] object print
in compiled code or
bind object print
in interpreted code. Alternatively, you can define the method with a
print-object), and then invoke it through the
name. Class binding is just a (often more convenient) way to achieve
the same effect; it avoids name clutter and allows you to invoke
methods directly without naming them first.
A frequent use of class binding is this: When we define a method
for a selector, we often want the method to do what the selector does
in the parent class, and a little more. There is a special word for
selector is equivalent to
parent is the parent
class of the current class. E.g., a method definition might look like:
:noname dup [parent] foo \ do parent's foo on the receiving object ... \ do some more ; overrides foo
In Object-oriented programming in ANS Forth (Forth Dimensions, March 1997), Andrew McKewan presents class binding as an optimization technique. I recommend not using it for this purpose unless you are in an emergency. Late binding is pretty fast with this model anyway, so the benefit of using class binding is small; the cost of using class binding where it is not appropriate is reduced maintainability.
While we are at programming style questions: You should bind
selectors only to ancestor classes of the receiving object. E.g., say,
you know that the receiving object is of class
foo or its
descendents; then you should bind only to
foo and its
Go to the first, previous, next, last section, table of contents.