[Xotcl] Dynamic dispatch and subclasses

[Neil Madden]

Hello all,

Just noticed the following behaviour in XOTcl:

Class Base
Base instproc foo {} {
     puts "Foo in Base"
}
Base instproc bar {} {
     # Just call foo
     my foo
}
Class Sub -superclass Base
Sub instproc foo {} {
     puts "Foo in Sub"
}
(Desktop) 56 % Sub a
::a
(Desktop) 57 % a foo
Foo in Sub
(Desktop) 58 % a bar
Foo in Sub

I was kind of expecting the last to say "Foo in Base", as the method 
call of "foo" was dispatched from the Base class level. This is an 
interesting problem, as I can see reasons why you might want to do the 
current behaviour. However, I'm worried about some of the implications 
of implementation details and name clashes. Suppose I implement some 
class Base, which as part of it's implementation has a (private) method 
DoStuff. Now suppose someone else sub-classes my class, and in their 
implementation, they also happen to have a DoStuff method - this is 
going to break my implementation. It seems like this is breaking 
encapsulation somewhat. It seems like the cases where this dynamic 
dispatch could be useful could also be solved by passing in an explicit 
callback - that way you aren't relying on an implementation detail.

Am I missing a good reason for this? My OO theory is perhaps lacking in 
this area. I can see that I can get around it easily by prefixing my 
private methods:

Base instproc BaseDoStuff {...} { ... }

but this seems a bit ugly (reminds me of pre-namespace Tcl). Does XOTcl 
have some other cool feature that I'm missing.

Cheers,

Neil.