PYK 2016-09-15: In the Tcl Chatroom recently, dbohdan mentioned that in Why Ruby is an acceptable Lisp (2005) ( , pjmlp mentioned working for a startup that had a Rails-like stack, but implemented in a mix of Tcl, Apache and C. This lead me to read Why Ruby is an acceptable LISP , Eric Kidd, 2005, and then to the venerable Revenge of the Nerds , Paul Graham, 2002. Where other languages provide closures, Tcl provides namespaces, which favor "explicit" over "implicit": Each namespace has a name, and its lifespan is under the manual control of the programmer. Below is a procedure, stowroutine, that simply creates a routine that has its own namespace to work in. A helper procedures, stowproc, exposes a stowroutine as a command, and another helper routine, stowsow, plants an existing routine in a new namespace. This suite of procedures accomplishes much the same thing as AMG's sproc, but in a more minimal way. Since an entire namespace is at its disposal, a stowroutine is a flexible creature. One thing to remain aware of is that management of the lifetime of the routine and of its namespace is delegated to the programmer.

A coroutine is of course another natural choice for this sort of thing, and it may even be useful to combine the two mechanisms to create a stowcoro.

#! /bin/env tclsh

proc stowroutine {ns argspec body} {
    list ::apply [list $argspec $body [
        uplevel 1 [list namespace eval $ns {namespace current}]]]

proc stowproc {name routine} {
    uplevel 1 [list interp alias {} [namespace current]::$name {} {*}$routine]

proc stowsow {routine namespace args} {
    set namespace [uplevel 1 [
        list namespace eval $namespace {namespace current}]]
    set spec [lindex $routine 1]
    set spec [lreplace $spec[set spec {}] 2 2 $namespace]
    lreplace $routine[set routine {}] 1 1 $spec


set p1 [stowroutine p1 count {
    variable a
    incr a $count 

stowproc p1 $p1
stowproc p2 [stowsow $p1 p2]

puts [{*}$p1 7] ;# -> 7
puts [p1 8] ;# -> 15
puts [p2 3] ;# -> 3

At first, stowproc looked like this:

proc stowproc {name routine} {
    uplevel 1 [list proc $name args "::tailcall {*}$routine {*}\$args"]

However, this folded $routine into a new string, so procedures based on the same stowroutine didn't share the byte-compiled compiled routine. The interp alias variant of stowproc fixes that.