Updated 2012-05-17 06:45:00 by dkf

Richard Suchenwirth 2005-03-25 - TOOT is "transparent OO for Tcl" - a "pure-value" approach, where a value (a listable string) like
 {Foo | bar grill}

is interpreted to be of class Foo (so Foo's methods can be applied to it), with the "instance variable" values bar and ''grill'. (In fact, they aren't "variable" - values are immutable).

The "|" as second element just identifies this as a TOOT value. "Transparent" means that a TOOT has nothing to hide - its state is fully visible in the string representation. For a "constructor", list is sufficient:
set c [list Complex | $real $imag]

but a few keystrokes add "constructor sugar", so you might as well call
set c [Complex | $real $imag]

No garbage collection is necessary: like all Tcl values, TOOT values just go away when nobody wants them any more (e.g. on return when associated with a local variable).

Methods are called as usual, with the method name (which can also look like "+") after the object, and then possibly more arguments. The example with the multiplication method named, evidently, "*" shows that the appearance of infix arithmetics comes as a by-product:
set i {Complex | 0 1}         ;#-- imaginary unit i
$i * $i  ==> {Complex | -1 0} ;#-- such that i*i == -1

Reinventing Complex math made simple, here's my experiments. Binary operators take one argument, which can be another Complex, or a real number x, which then gets "upgraded" to [Complex | $x 0]. A single proc contains all methods for the Complex "class":
 proc Complex {| r i {method ""} args} {
    if {[llength $args]==1} {
        set operand [lindex $args 0]
        if [string is double -strict $operand] {
            set r2 $operand; set i2 0
        } else {foreach {Complex | r2 i2} $operand break}
    }
    switch -- $method {
        ""   {list Complex | $r $i ;#--constructor sugar} 
        real {set r}
        imag {set i}
        abs  {expr {hypot($i,$r)}}
        arg  {expr {atan2($i,$r)}}
        format {expr {$i ? "$r+i*$i" : $r}}
        ==   {expr {$r==$r2 && $i==$i2}}
        !=   {expr {!($r==$r2 && $i==$i2)}}
        +    {Complex | [+ $r $r2] [+ $i $i2]} 
        -    {Complex | [- $r $r2] [- $i $i2]}
        *    {Complex | [expr {$r*$r2 - $i*$i2}] \
                             [expr {$r*$i2 + $r2*$i}]
             }
        /    {set div [expr {$r2*$r2 + $i2*$i2}]
              Complex | [expr {($r*$r2 + $i*$i2) / $div}] \ 
                             [expr {($r2*$i - $r*$i2) / $div}]
             }
        default {error "unknown method $method"}
    }
 }
#-- For convenience, [expr] operators are exported as commands:
 foreach op {+ - * /} {proc $op {a b} "expr {\$a $op \$b}"}

To make this flavor of TOOT work, we let unknown know it shall auto-expand the first word if its second element is "|" :
 proc know what {proc unknown args $what\n[info body unknown]}
 know {
    if {[lindex $args 0 1] eq "|"} {
        return [uplevel 1 [lindex $args 0] [lrange $args 1 end]]
    }
 }
#-- This little tester reports the unexpected
 proc ? {cmd expected} {
    catch {uplevel 1 $cmd} res
    if {$res ne $expected} {puts "$cmd -> $res, expected $expected"}
 }
#-- The test suite passes silently when all goes well:
 set i {Complex | 0 1}     ;# flat value
 set b [Complex | 3 4] ;# constructor sugar
 ? {$b format} {3+i*4}
 ? {$b abs}     5.0
 ? {$b real}    3
 ? {$b imag}    4
 ? {$i == $i}   1
 ? {$i == $b}   0
 ? {$i != $b}   1
 ? {$i + $b}    {Complex | 3 5}
 ? {$b - $i}    {Complex | 3 3}
 ? {$b + 1}     {Complex | 4 4}
 ? {$i * $i}    {Complex | -1 0} ;# i**2 == -1?
 ? {[$i * $i] format} -1
 set r   [$b abs]
 set phi [$b arg]
 ? {[[Complex | [expr cos($phi)] [expr sin($phi)]] * $r] == $b} 1
 ? {$b / 0}               "divide by zero"
 ? {$b / {Complex | 0 0}} "divide by zero"
 ? {$a foo}               "unknown method foo"

See also Straightforward implementation of complex numbers which is included in recent Tcllib