proc in Tcl oo::class - oop

Question

A silly question. I have a oo::class and make an awful thing - including procs into a constructor and a method:
oo::class create MyClass {
constructor {args} {
proc silly {args} {
puts "-------------silly's args: $args"
puts namespace=[namespace current]
set v [namespace current]::sillyvar
puts $v=[incr $v]
puts vars=[info vars [namespace current]::*]
}
}
destructor {
foreach proc {silly SILLY} {
rename $proc ""
}
}
method createprocs {} {
proc SILLY {args} {
puts "-------------SILLY's args: $args"
set v [namespace current]::sillyvar
puts $v=[incr $v]
}
}
method another {} {
silly ;# works ok
}
}
MyClass create myobj
myobj createprocs
[info object namespace myobj]::silly hello world
myobj another
[info object namespace myobj]::SILLY HELLO WORLD
MyClass destroy
The output looks OK:
-------------silly's args: hello world
namespace=::oo::Obj12
::oo::Obj12::sillyvar=1
vars=::oo::Obj12::sillyvar
-------------silly's args:
namespace=::oo::Obj12
::oo::Obj12::sillyvar=2
vars=::oo::Obj12::sillyvar
-------------SILLY's args: HELLO WORLD
::oo::Obj12::sillyvar=3
Can you kind folks say, is it correct? And if so, where it can be useful?
What I see just now is:
1) The silly and the SILLY both are 'exported'.
2) I need no "my silly" and "[self] silly" to access the silly proc from an object.

Answer 1

Can you kind folks say, is it correct?
It looks OK to me, except that you don't need the destructor. The procedures are created in the object instance's namespace (which is also where the object's variables are, FWIW) and that's automatically deleted when the object is destroyed (and vice versa too; you can't have one without the other).
And if so, where it can be useful?
I use procedures (and other commands) created inside methods and constructors a fair bit. They can do things like acting like a private sub-language of Tcl and so on (just as you can do with putting commands in a normal namespace; it's not significantly different), so that's really quite useful. They're also very easy to delegate to using a forwarded method.
One of the easier tricks is to make a sub-object inside an outer object and to delegate some method calls through:
oo::class create Outer {
constructor {} {
Inner create inner [self]
puts "created [self]"
}
destructor {
puts "destroyed [self]"
}
method foo {} {
puts "this is foo of [self]"
}
forward bar inner foo
}
oo::class create Inner {
constructor {outer} {
puts "created [self] inside $outer"
}
destructor {
puts "destroyed [self]"
}
method foo {} {
puts "this is foo of [self]"
}
}
Demonstrating this:
Outer create x
# ⇒ created ::oo::Obj13::inner inside ::x
# ⇒ created ::x
x foo
# ⇒ this is foo of ::x
x bar
# ⇒ this is foo of ::oo::Obj13::inner
x destroy
# ⇒ destroyed ::x
# ⇒ destroyed ::oo::Obj13::inner
This shows the containment and delegation at work (which is based on the same mechanism that your procedures would be using). As you can see, inner is made inside the private namespace of x, and x bar is routed through to inner foo. Even better, when x is destroyed, so is inner with no special code at all; that's very useful in complex code.