mathematical set

4 Jan 2006 - Googie - Here's some very simple way to use set command like the following:

 set a 5
 set b $a + 3 + ($a * 2)
 puts $b

'$b' will be 18. The only requirement is to use 'mathematical' set case with more than 1 and 2 arguments (which are number of arguments for default set syntax). In practise it means that you have to do at least one white-space in math expression, or set will be interpreted as the Tcl-built-in one. Here's code to enable such functionality:

 rename ::set
 proc ::set {var args} {
     if {[llength $args] > 1} {
         uplevel [list $var [eval expr "{$args}"]]
     } else {
         uplevel [list $var [lindex $args 0]]

RS: Cute. But the case of [llength $args]==0 should also be covered as returning the value - right now it would set it to {}. Also, all the efficiency gained with braced expressions is of course lost here...

WHD: I prefer "let", as in

 let b {$a + 3 + ($a * 2)}

or especially

 let x {$x + 1.5}

Implemented in C, it's also reasonably fast.

escargo 10 Jan 2006 - I kind of like that distinction (that is, between set and let). (Maybe because I was exposed to some form of BASIC in ancient times.) It certainly is less typing to write

 let x {$x + 1.5}


 set x [expr {$x + 1.5}]

What about allowing bare words to dispense with the $? (Since the braced expression is a right hand side, after all.) That would give

 let x {x + 1.5}

Is that too radical a change?

RS: It might cause conflicts between functions and arrays:

 let x {sin(x)+cos(y)}

Lars H: IMO, it wouldn't be onerous to continue to require $ for arrays.

 let r {$A(i) + cos(omega*j)}

Perhaps also some shorthand for lindex while we're at it? I think # is unused.

RS takes this cue to let unknown know:^)

 % know {if {[lindex $args 1] eq "#"} {return [lindex [lindex $args 0] [lindex $args 2]]}}

 % {hello world out there} # 2
 % set test {1 2 3 4 5 6 7}
 1 2 3 4 5 6 7
 % set t [$test # 4]

NEM likes adding a touch more sugar and having:

 let x = {$x + 1.5}

escargo 11 Jan 2006 - One of the reasons I like plain let instead of set is because it is shorthand. Having the = adds more characters, which is the opposite of the goal of shorthand. You could go farther down this path and do

 = x {x + 1.5}

as a somewhat more radical version. It's even shorter. I still prefer let, though.