[Xotcl] poll for opinions

[Gustaf Neumann]

 Dear XOTcl community,
 
 we are working currently on various issues which we
 think are important for our 1.0 release:
   
   - speedup through byte-code support
   - better components with introspection facilities
   - easy to use rel-db interface
   ...
 
 concerning the first item: i was performing some 
 experiments for providing extension-specific 
 byte-code support, e.g. to allow to register
 byte-code instructions for the most-used commands
 in XOTcl (such as [self], next, etc.). through
 these xotcl-specific bytre-codes we get
 nice improvements (e.g. [self] 
 is more than 10 times faster, some benchmarks 
 improve by 40%). This improvements require 
 a patch for tcl, which is therefore not acceptable
 for most people now. We talked to the Tcl 
 implementors to include such a patch, but currently
 some of them think about a substantial redesign 
 of the bytecode which has much more constraints once
 extension writers depend on the current design, so 
 i don't expect that a patch with this functionality
 will be intergrated in tcl in the new future.

 however, there is already some influence for XOTcl:
 In Tcl, compilation is command based: this means, 
 for every call of a command literally available in
 the the body of a proc, a bytecode sequence can 
 be provided by the command. This means that it 
 is possible to compile the body of method m1 in  
   Object o
   o proc m1 {} {
     o set x 123
   }
   o proc m2 {} {
     [self] set x 234
   }
 to something clever, but not the body of m2,
 since the command in the body of m2 depends on 
 the results of [self] which the compiler does not know. 
 Since m2 is the much
 better style, we should address this principal
 problem, since this will ease future improvements for xotcl. 
 An easy soultion is to provide a tcl-command
 selfInvoke, which can be byte-compiled. selfInvoke has
 the following sematics
   
  proc selfInvoke args { eval [self] $args } 

 and if implemented in C, it leads already to 
 some speedup (without bytecode support), since the call 
 of the tcl command "self" is replaced internally by a 
 call to a c-function.

 Another advantage is that the number of [self] in an
 xotcl script is reduced, an programs might become easier
 to type ()since less shilft/alt/.. keys have to be pressed)
 and hopefully less "cluttered" to read.

 yet another advantage is that this change makes in a program
 more visible when a delegation is used (call to a 
 different object) instead of the call of the current
 object.

 since "selfInvoke" is not something i would like to 
 type often either, and this is rather a language
 primitive, we are considering some syntactical 
 alternatives, and want some input from the 
 "community". Certainly, the explicit call of [self] or 
 to another object will be supported in the future as well.

 what do you think about the following variants:

   o proc m1 {} {
     [self] set x 123
   }
   o proc m2 {} {
     .. set x 123
   }
   o proc m3 {} {
     = set x 123
   }
   o proc m4 {} {
     => set x 123
   }
   o proc m5 {} {
     - set x 123
   }

 other ideas?

 note, that the used symbol cannot be used as an 
 (global) object name (same as with next, self, set, 
 and other global tcl commands)

 what do you think? 

 best regards
 -gustaf neumann