Version 124 of tclOO missing features for Itcl

APW 2007-06-06 Some time ago I started efforts to reimplement Itcl on top of tclOO [L1 ]. I started with tclOO using only the API of Itcl; it had about 90% of the test suite of Itcl running successfully, but I saw that after all I was only using a small part of tclOO.

Second approach was implementing a TMOS [L2 ]-like extension using a lot of code of the XOTcl reference implementation but having again about 90% of the test suite of Itcl running successfully. I felt that the code was too big and too complicated, partially because of having all these XOTcl features running. Additionally there were some features of Itcl which would have needed a lot of redesign of that code to pass the Itcl test suite.

So I decided to come back on the tclOO implementation, thinking that is after all the best starting point. This time changing/extending the tclOO code directly to be able to use as much as possible of that code, because I had the feeling it has a lot of good implemented features, which I did like to use. I did also like the implementation of the dispatch and class/object creation mechanism realized there much more then the one in the TMOS implementation.

I started implementing extensions to tclOO (directly in tclOO, as the API is not enough) to get a lot of features of Itcl to run. This includes also a lot of code implemented in pure Tcl above tclOO as far as possible. Doing that I learned a lot more details and "specialities" about Itcl.

Currently I have an implementation which is successfully about 70% of the Itcl test suite.

Having now a better feeling about what is needed for Itcl I will start to write down the missing features and my solution for it in the hope that there will be some comments (especially from dkf). These could also include suggestions on how to solve the problem in a different way, without having to modify tclOO.

In the following solution means: that is my current (not always optimal) solution for the problem.

In the code examples I am using a meta syntax not the Itcl or tclOO syntax to make the code shorter!

Here starts the list; I will add topics if they come up:

Namespace names for Itcl

problem: Itcl expects that the namespace of a class is the same as the class name
solution: add an option -withnamespace or a method createwithnamespace

calling of methods without my infront of the method name

problem: Itcl resolves command calls first within the class hierarchy before using the normal Tcl rules
solution: add a namespace unknown command as a dispatcher for Itcl methods

access to class variables

problem: Itcl has 3 protection levels which guard the access to class variables in the class hierachy.
solution: I use the apply command for constructing the body parts for the class methods (and constructors and destructors) after the complete class has been parsed and all classes in the hiearchy are known. There is an additional parameter, self, added automatically to the arguments of the method and the variables of all the classes in the hierarchy are mapped using namespace upvar. Variables in Itcl have to live in the namespace where they are defined as there might be the same variable name in different classes in the hierarchy even with different protection (private, protected public). In generating the namespace upvar commands the private variables of inherited classes are skipped.

Itcl rules for calling/traversing the constructors and destructors

problem: the rules for traversing the constructors/destructors in Itcl are very "special" and cannot be mapped to the model in tclOO. Example:

  class foo {
      constructor {args} { puts foo }
  }
  class bar {
      constructor {args} { puts bar }
  }
  class foobar {
      superclass foo bar
      constructor {args} { puts foobar }
  }
  class geek {
      constructor {args} { puts geek }
  }
  class mongrel {
      superclass foobar geek
      constructor {args} { puts mongrel }
  }

  output: geek bar foo foobar mongrel

 In words Itcl: look in the superclasses starting at the end of the definition,
 look for inherited classes as long as they exists, if at the root unroll the
 built stack. go to the next class in inheritance, do the same.

solution: new command invokeitclconstructors similar to [next] command in tclOO (to be done: add details here)

Itcl special init code script in constructors

problem: in Itcl constructors it is possible to define an init script, which is invoked directly before the code in the constructor, but after the object is instantiated. Example:

  the script after the arguments and before the body is the "constructor init code"

  class foo {
      constructor {args} { puts foo }
  }
  class bar {
      constructor {args} { puts bar }
  }
  class foobar {
      superclass foo bar
      constructor {args} {
         foo::constructor ; # this is the init code which calls the constructor of class foo
      } { puts foobar }
  }
  class geek {
      constructor {args} { puts geek }
  }
  class mongrel {
      superclass foobar geek
      constructor {args} {
        foobar::constructor
      } { puts mongrel }
  }

  output: foo bar foobar geek mongrel

solution: add the init code script in building the apply code for the constructors

Itcl special command itcl::body

problem: In Itcl it is possible to define a method only partial: protection + name, protection + name + params, protection + name + params + body. That method can be redefined later on, but the params list for the method - if defined in the class definition - has to be compatible. That method can be redefined later on, but the params list for the method - if defined in the class definition - has to be compatible.
solution: add additional information about method params and status to each method definition in the tclOO internal structures. Here is also the problem that tclOO cannot handle partially defined methods, which the solution is adding as functionality.

Itcl info command

problem: one of the problems: getting the original body of a method when using apply internally
solution: save the original body in the tclOO internal structures of a method. In general I am generating a method info (within each class and as a proc in Itcl syntax it is something like a singleton method and it can be called without an object being instantiated) which is first trying the Itcl specific commands, and if that does not work it forwards to the ::info command

[ Category Object Orientation | Category discussion | Category Itcl ]