The top level of parenthesis-es is left out, the other levels replaced by brackets :). But joking aside, I greatly enjoy both Lisp and Tcl as languages.

A huge, seriously annoying problem with TCL is lack of deterministic cleanup for resources. If you don't manually close a filehandle, for example, it will leak. Doing this sort of bookkeeping in 2015 is infuriating.

This illustrates how you can use Tcl to ensure that files get closed even when errors happen by combining catch, close and return (from the Tcl manual):

    proc withOpenFile {filename channelVar script} {
        upvar 1 $channelVar chan
        set chan [open $filename]
        catch {
            uplevel 1 $script
        } result options
        close $chan
        return -options $options $result
    }

  proc with {file as name block} {
    uplevel 1 [list set $name $file]
    uplevel 1 [list eval $block]
    uplevel 1 [list close $file]
  }
  
  with [open foo.txt w] as file {
    puts $file "Hello, World!"
  }

I'm sure it's possible to do it in a cleaner way without [set], but my Tcl is a bit rusty.

I like the "with". Python has that construct. It's not annoying and easy to remember.

Still leaks on an exception. That's also an annoying construct to be forced to use.

You could easily wrap the middle uplevel in a catch block to handle exceptions, and this sort of "with" construct is pretty common in a lot of very popular languages today.

While it would be nice if this were baked into the language, it's pretty astonishing how extensible Tcl is without even having to touch the realm of C extensions.

I think this precisely one of Tcl's strengths. Few other languages apart from Lisp and Tcl lets you write your own control flow syntax from within the language (and at runtime).

Garbage collecting languages will free memory, but that's all they're good for. C++ destructors will let you close a filehandle, but I know of no other language that will deterministically clean up non-memory resources.

So: What language(s) did you have in mind that do this right?

Lisp for example has unwind-protect, which is guaranteed to run the unwind code when you leave its scope in which way whatever (be it an exception or a return). So this is a reliable way of running clean-up code at the end of a code block.

Many scripting languages in practice do reference counting GC that will reliably and deterministically clean up resources other than memory.

"Many" includes Tcl there. I have no idea why you think differently. Tcl has had it since the 8.X series started (at least).

Not for tcloo objects, channels and file handles. I don't think you get it. In sane languages like C++ you can expect a destructor to call itself no matter where a function exited.

C++ is not a scripting language. Give me a scripting language that does that so I can research and compare.

perl:

    sub do_stuff {
        my $thing = Thing->new; # no need to manually destroy thing. Its DESTROY method will be called at the closing brace.
    }

Cool...now I get to play. Perl does it because it goes out of scope once the sub is run. I am pretty sure you can tell TclOO to do the same thing (play time) if it already doesn't do that.

In the end, they all make trade offs depending on the "whim" of the language designer.

Jesus Christ, you don't even know tcl. Why are you blathering on here? No, tcloo objects are not garbage collected. That's the whole point here.

Yeah just blathering. Carry on.

So, about four posts before this one, you said:

> Many scripting languages in practice do reference counting GC that will reliably and deterministically clean up resources other than memory.

When challenged, you offered one. So, is this a Perl-only thing, or can you give other examples?

Programming must by hard for you. Have a cookie.