[Xotcl] Re: class methods

[Gustaf Neumann]

On Wednesday 25 April 2001 20:51, Artur Trzewik wrote:
> Halo
>
> The problem is more complicated than I have expected.
> It is true, proc are not good for this purposes.
> Classproc are very good idea but it would complicate the model.
>
> It is really a program style not to use class methods.
> If you come from C++ or Java (brr...) you will seldom use it.
> Smalltalk-programmers will miss it (there are many smalltalk based
> languages) A main usage is individual instance creation
> (such as Factory Patterns in C++ or type based polymorphismus)
> for example
>
> MyClass createFromXML "...xml string"
> MyClass createFromFooObject   myObject
>
> C++ programmers will write
>
> class MyClass {
> public:
>      MyClass(XMLNode node);
>      MyClass(FooClass myObject);
> };

 i would recommend to use "-methods" to tag the type; at the
 place, where you create instances of myclass, you will most probably
 know the kind of argument you are passing:
 
 Class MyClass
 MyClass instproc xml value { ;# convert xml value to internal rep
    ...
 }
 MyClass instproc obj value { ;# convert obj to internal rep
    ...
 }
 ...
 MyClass o1 -xml "...xml string"
 MyClass o2 -obj myObject


> > InheritClassProc instproc unknown {m args} {
> >   foreach c [[self] info heritage] {
> >     if {[info command ${c}::$m] != ""} {return [eval $c $m $args]}
> >   }
> >   next
> > }
> > Class instmixin InheritClassProc
>
> The solution do not do what I expect
> See this example. It demostrate how inheritable class method can be used
>
> Class TkWidget
> TkWidget proc testMe {} {
>    set toplevel [toplevel [Object autoname .toplevel]]
>    set inst [[self] create [Object autoname twidget] ${toplevel}.test]
>    pack $toplevel.test
>    return $inst
> }
> Class TkText -superclass TkWidget
> TkText instproc init {win} {
>      text $win
> }
> Class TkEntry -superclass TkWidget
> TkEntry instproc  init {win} {
>      puts "window $win"
>      entry $win
> }
> TkEntry testMe

 i see; what you want is not delegation to the class, where the 
 proc is defined (in this case the call to [self] in testMe would
 return "TkWidget"), but you want to evaluate the method testMe in the
 context of the calling class ([self] in testMe will return "TkEntry")

 Fortunately, we have a questionable feature in xotcl, which allows this
 currently, but notice that you have limited interception capabilities.
 it is possible to call a proc directly, bypassing the xotcl dispatcher.
##################################################################
Class InheritClassProc
InheritClassProc instproc unknown {m args} {
  foreach c [[self] info heritage] {
    if {[info command ${c}::$m] != ""} {
      return [eval ${c}::$m $args]
    }
  }
  next
}
Class instmixin InheritClassProc
###################################################################

 a casual reader will hardly notice the difference, but instead of calling
 '$c $m $args', a call to '${c}::$m $args' is performed.

 if i look at your program, the main reason for using the class proc seems
 to be to call "pack" **after** init without the need to write it into
 TkEntry or TkText. You can also use filters or an instmixin to achieve the
 same behavior:

==========================================================================
Class TkPacker
TkPacker instproc init args {
  set r [next]
  pack [[self] set name]
  return $r
}

Class TkWidget -instmixin TkPacker
TkWidget instproc init {} {
  [self] instvar toplevel
  set toplevel [toplevel [Object autoname .toplevel]]
  [self] set name ${toplevel}.[string trimleft [self] :]
}
Class TkText -superclass TkWidget
TkText instproc init {win} {
  next
  text [[self] set name]
}
Class TkEntry -superclass TkWidget
TkEntry instproc init {} {
  next
  entry [[self] set name]
}
TkEntry a
==========================================================================

 This version has the advantage that you get more predictable widet names.


> I will try to use metaclasses for my problems.
> It can be good to take a look on other new objectbased languages
> ruby, self, python.
> How do these languages handle class methods?


 this is not an easy question; the language of this list which is closest
 to XOTcl is ruby, which has a single construct named "def" to define a 
 proc or instproc (in xotcl terms). within a class definition, def Classname.methodname
 defines a class method. there is no word about inheritence of class procs in the
 documentation.

 self is quite different, since self does not have classes, but traits and mixins,
 which provide a bundle of methods through specially marked "parent" slots. since
 there are not classes, class methods can't be defined. As i see it, one needs 
 can define two slots for traits, one defined as a parent slot (which will provide
 methods for the "instances", and another slot for a separate object, that can be
 reached via delegation, which will have the counterpart of a proc. Two objects can 
 share a trait, therefore it is possible to define something like inherited class procs 
 by "manually" assigning the appropriate slot to all involved objects. This is like defining
 per object mixins to all effected classes. therefore, the short answer is no, there
 is no direct language support for this behavior.
 
 python has a rather week oo support. it has no distinction between instproc and proc,
 all methods are defined by "def". python has no class methods. the trick to achieve
 a similar behavior in python is to define a "module" and to define in the module
 a function outside the scope of a class. Therefore: there is no way get inheritance.

 hope this helps
-gustaf