Lars H: I had a look at Icon, and got interested in the unusual approach towards conditionals in that language. Some of that can (of course) be done in Tcl too, so I had a go at it. I find them intereting because they demonstate one way in which one could remove the expr "little language" from core Tcl (not very useful, but interesting for stylistic reasons).
The basic idea is that commands either fail or are successful. When some part of a composite command fails, the whole thing fails, and the other parts of it won't be executed. This is simply the way that Tcl return codes work, so we have that already. Failure could be coded as a straightforward error, but that carries some overhead in constructing the errorInfo (or at least some people are very keen on saying it does), so I will use a special fail command instead.
proc fail {} {return -code 5}The relevance this has for control structures (if, while, etc.) is that these use the success/fail status of the condition, rather than its value, to decide what to do. Therefore the operations can return something other than the boolean result as value. One example might be
proc lcontains {list item} {
set n [lsearch -exact $list $item]
if {$n>=0} then {return $n} else {fail}
}which could be used as
f-if {set n [lcontains {red green yellow blue} $col]} {
# Success case:
puts "This is colour $n."
} {
# Failure case:
puts "I don't know that colour."
}(Whether this is good style is debatable, but in some cases that order of operations appears natural.)
A simple implementation is
proc f-if {condition then else} {
if {![catch {uplevel 1 $condition}]} then {
uplevel 1 $then
} else {
uplevel 1 $else
}
}and analogously
proc f-while {condition body} {
while {![catch {uplevel 1 $condition}]} {
uplevel 1 $body
}
}Defining > as another fail-type test,
proc > {a b} {
if {$a > $b} then {
return $b
} else {
fail
}
}one can write things like
set n 1; set m -3
f-while {> [> 14 $n] $m} {
incr n 1; incr m 2
}although that has probably lost much of the beauty in the infix equivalent 14 > $n > $m (14 is greater than n AND n is greater than m).
In the construction of elementary operations department, one can note that logical and is simply ; -- a condition can be more than one command, and it only succeeeds if they all succeed. Logical not can be expressed in terms of f-if:
proc f-not {condition} {f-if {uplevel $condition} {fail} {}}and then logical or is simply a matter of suitable double negation:
proc f-or {args} {
f-not {
foreach condition $args {
f-not {uplevel $condition}
}
}
}