Simplification of the Tcl language

LEG 20081209:

Multiple Return Values

Are discussed in the page Everything is a list

blocks/loops with progn functionality

I want for foreach and while to evaluate to the value of the last executed command.

I want break accept (multiple) arguments just like return (as in Multiple Return Values)

Extensive use of variadic functions

One of the nice things about Tcl is, that lot's of its commands take an arbitrary list of arguments and do something sensible with them. If the return values of commands could also be variadic (see Multiple Return Values), we could stack and stack and stack and ... one command on the other easily.

The following are some salvage ideas for modified Tcl commands.

'What if

  • All commands for which it is sensible process an arbitrary length argument list.
  • All commands for which it is sensible returns a list. See examples.
  • A new command "args" is introduced, it is used for args expansion.

Examples for list aware commands:

set v
return the value of v
set v args
set v to the list created by concatenation of all args and return it
puts ?-chan channel? ?-nonewline? ?args?
concatenate all args and write them to channel. default channel is stdout
gets args
each arg is a channel, get a line from each of them and return a list in the order of the channels. if args is empty get a line from stdin
close args
close all channels
return ?-code code -errorInfo info -errorcode code? args
concat all args and return them
incr args
interpret args as list of varName increment pairs. return list of incremented values. If the list has an odd number of arguments, the last variable will be incremented by 1.
array exists args
args is a list of arrayNames returns a list of flags for existence of each arrayName
array get -pattern patternList args
args is a list of arrayNames it returns a list of {key value} pair lists, which are the matches of each pattern of patternList in the respective arrray


Variadic versions of typical Tcl commands are implemented with the same name with a '*' at the end.

proc args {} {uplevel set args}
proc return* args {
    set opts {}; set i 0
    foreach {o v} $args {
        switch -exact -- $o {
            -code - -errorinfo - -errorcode {
                lappend opts $o $v; incr i 2
            -- {incr i}
            default {break}
    uplevel return $opts [list [lrange $args $i end]]
proc set* {varName args} {
    uplevel set $varName $args
proc puts* args {
    set opts {}; set i 0
    set chan stdout
    foreach {o v} $args {
        switch -exact -- $o {
            -chan {set chan $v; incr i 2}
            -nonewline {
                lappend opts -nonewline
                incr i
            default {break}
    foreach e [lrange $args $i end] {
        uplevel puts $opts $chan [list $e]

proc retThree {} {return* 1 2 3}
proc retOne {} {return* {1 2 3}}
proc returnOne {} {return {1 2 3}}
proc retMany args {return* {*}[args]}

puts* "puts* retThree:" {*}[retThree]
puts* "puts* retOne:" {*}[retOne]
puts* "puts* returnOne:" {*}[returnOne]
puts* -nonewline "puts* -nonewline returnOne:\\n\n" {*}[returnOne] \n
puts* "puts* retMany a b c d" {*}[retMany a b c d]