Consider this example:

======
proc show_invocation {} {
    return [info level -1]
}


proc a args {
    puts {Beginning of a.}
    puts [show_invocation]
}


proc b args {
    a x y z
}

proc c args {
    b 1 2 3
}

c skip-to-my-lou
======

It has output 

======none
Beginning of a.
a x y z
======

In English words, this illustrates that a [proc] can report on the command-line
which invoked it.  In particular, this provides a base for introspection on the
'''proc''' call-stack, coded in "[Printing proc sequence]", "[A basic debugger]", 
"[List the call stack]", and perhaps elsewhere.

----

[wdb]: Exactly that's the way the OO system [obj] works: 
an object is a reference to the base procedure called _root-object_,
and is created by namespace import ::obj::class::${classname}::_root-object_,
then renamed to something like ::obj::inst::''new-name''.
The reference is located in a namespace ::obj::inst;
the name originally called is used as object identifier.

Example: 

======none
% set c
::obj::inst::4
% namespace origin $c
::obj::class::curve::_root-object_
% sourceCode $c
proc ::obj::class::curve::_root-object_ {{method ::return} args} {
     $method [lindex [::info level 0] 0] {*}$args
   }
% 
======

[Lars H]: An alternative solution for this kind of thing is to make the instance command an [interp alias] to the _root-object_ command, and include the instance name in the [command prefix] for this alias. In the above example, that would amount to roughly
 interp alias {} ::obj::inst::4 {} ::obj::class::curve::_root-object_ ::obj::inst::4
 proc ::obj::class::curve::_root-object_ {self {method ::return} args} {
      $method $self {*}$args
 }
(could almost make the _root-object_ command an [ensemble with parameters] as well to further speed up the dispatch, but that won't let you omit the method name).
''Important difference:'' With the alias technique, the "self" value stays the same if the object command is [rename]d, whereas with the [info level] technique it changes to match the new command name. Whether this is a pro or con depends on how you use it.

[wdb] When making [obj], the drawback of objects not to be renameable I took as a bearable one.
My intention was maximum speed on generating multiple, partially just once-used local objects
which not even are bound to variables.

----

There's more, though:  with 8.5, it becomes possible to write

======
package require Tcl 8.5

proc show_complete_invocation {} {
    array set frame [info frame -2]
        # Memory leak ahoy!  In non-toy code, the file 
        # handle deserves its [close].
    set lines [split [read [open $frame(file)]] \n]
    return [lindex $lines [expr $frame(line) -1]]
}


proc a args {
    puts "Beginning of a."
    puts [show_complete_invocation]
}


proc b args {
    a x y z
    set x [a b c d]
}

proc c args {
    b 1 2 3
}

c skip-to-my-lou
======

The output of ''this'' script is

======none
Beginning of a.
      a x y z
Beginning of a.
      set x [a b c d]
======

While this is a bit fragile in that it requires a few more lines to
handle dynamic `[proc]` definitons and other complications, it should at least
hint at the possibilities of this sort of introspection.



<<categories>> Introspection | Object Orientation