[CMcC] Two fundamental types in tcl core are [Tcl_Obj] and [Command].

Both maintain some state, are refcounted, can be named and define some intrinsic operations.

----

'''Purposes''':

The first element of a string to be evaluated must be a Command.  The primary carrier of value is a Tcl_Obj.

Tcl_Obj's are arguments to and results from evaluation of Commands.

In short:  Commands evaluate Tcl_Objs. 

----
'''Anatomy''':

Tcl_Obj is typed, and provides the following operations:

   * Deletion - state is freed
   * Duplication - copy self's state to target
   * Serialization - update self's string representation
   * Mutation - transform state and type of object to this, or error.

Tcl_Obj provides for a string representation and an internal representation comprising storage for up to two pointers.

Command provides the following operations:

   * Deletion - free state and references to this Command
   * Evaluation - given a processing context and some arguments, produce a result.
   * Compilation - transform this command into a compiled form.
   * Tracing - invocation of Command may be traced.

Command provides state comprising: a [binding], a list of [namespace] import references to this command, and most importantly: client state associated with the Deletion and Evaluation operations.
----

'''Similarities and Differences''':

Both can be deleted.

Tcl_Obj can be duplicated, and can mutate some other value to itself, and itself to a string.

Command can be evaluated and compiled.  Since a Command is inherently named, duplication makes no sense, because duplicating a (name,value) pair is always an identity.  However, [rename] can be considered a similar kind of function, in that it creates identical state with a new binding.

Command doesn't have a string representation, doesn't provide a Serialisation operation.  This makes sense, to some extent, because its state (comprising C functions) is not meaningful as strings.

[proc] is the only way to transform a Tcl_Obj into a Command in vanilla tcl.  [itcl] and [xotcl] provide other ways to generate Command from Tcl_Obj.

----
'''Unification''':

Notwithstanding the differences between them:  If a Command were represented as a Tcl_Obj, how would it look?

If we wanted to create a Tcl_ObjType which wrapped a Command, we would be trying to provide meaningful equivalence between the Tcl_Obj operations (Deletion, Duplication, Serialization, Mutation) in terms of the Command operations (Deletion, Evaluation, Compilation)

   1. Deletion is directly analogous - a CommandObj would invoke Command's deletion function.

   2. Compilation is the transformation of internal state into ByteCode, essentially, so it is analogous to Tcl_Obj Serialization, except that not all Commands are able to be compiled, whereas all Tcl_Objs have a string representation.

   3. Duplication is similar to [rename]

   4. Mutation is similar to [proc]

   5. Evaluation has no equivalence, except that all Commands can be evaluated much as all Tcl_Obj can be serialised.

Evaluation and Serialization seem most closely analogous, in that All Commands can be Evaluated and All Tcl_Obj can be Serialized.  It may be that a CommandObj would use Tcl_Obj Serialize to Evaluate.

----
[[[Category Concept]]]