Hacker News Reader

Comment by bloaf | Hacker News Reader

To really show how much "everything is a string" in Tcl, I love the "sum a list" one liner:

    set a [list 1 2 3 4]
    set sumValue [eval [join $a +]]

[join $a +] produces a string "1+2+3+4" from the list {1 2 3 4} which you then evaluate to find the sum. Note that you do not need quotes around the +, tcl by default treats everything as a string.

Another example:

    set b a         #b now contains the string "a"
    set a 5         #a now contains the string "5"
    set var5 Steve  #var5 containst the string "Steve"

    puts $b      #write the value of b to the console: "a"
    puts $$b     #writes "5" to the console
    puts $var$$b #writes "Steve" to the console

View on HN

Some of these things do not quite work this way, but they demonstrate some interesting peculiarities! The eval should be expr, as you are trying to evaluate a mathematical expression, not a command. Similar to the common footgun:

    set a 1
    puts [expr $a + $a] # Wrong!
    puts [expr {$a + $a}] # Correct

Also $$b expands to $a, not 5, as dollar expansion stops at the next non-alphanumeric-or-underscore character. This would usually be written as [set $b] (equivalent to [set [set b]] ), utilising that the set command outputs the value of the variable with that name. Similarly, [set var[set $b]] for the last line. Also, # is only a special character at the beginning of a statement, so comments have to follow a newline or semicolon.

In the “everything is a string” department, my favourite are block comments:

    if 0 {
        This is a comment.
    }

You can write any kind of comment in there, even special characters like $undefined or [undefined] which would cause errors in normal code. Only wrongly matched {} would be a problem.

mea culpa on the eval/expr. I did the comments inline for brevity.

I am confused about the $$ examples though, since swear I have worked on production code that literally behaves like that. Maybe they had some extra non-alphanumeric bits. This behaves the way I gave originally

    set b a
    set (a) 5

    puts $($b)

Edit: I found the production code. There was both

    puts [expr 3 - $$b]

and

    puts [subst $$b]

and the Steve example was actually two steps:

    set nameVariable [subst var$$b]
    puts  [subst $$nameVariable]

Yeah, that is another dark corner. I was not quite precise (I forgot this behaviour existed): $ expansion does allow for parentheses as well, so that arrays work. Meaning $($b) is the same as [set ($b)] which is element $b of the array in variable {} (empty string; that is the name of the variable). The docs [1] say:

> $name(index)

> Name gives the name of an array variable and index gives the name of an element within that array. Name must contain only letters, digits, underscores, and namespace separators, and may be an empty string. [...] Command substitutions, variable substitutions, and backslash substitutions are performed on the characters of index.

So that means:

    set b a
    set (a) a  ;# this sets element a of the variable {} to a
    puts $($b) ;# prints that element
    info vars  ;# all variables, note that {} is in there
    puts $($($($b))) ;# Of course this works...

[1] http://www.tcl.tk/man/tcl8.6/TclCmd/Tcl.htm#M14

Yes, and this everything goes makes it difficult to spot bugs. Perl byte-code compiled a program at start and was able to find a number of bugs (if the warnings option was enabled). If e.g. a variable is misspelled in TCL, you'll find out exactly when that particular line of code is reached. If that happens to be in the error path ...

Reply on news.ycombinator.com