I think I lifted this from wikit many winters ago:

# lists and arrays with sugar
set rgx {([0-9A-Za-z_]+):([0-9A-Za-z_]+)$}
if [regexp $rgx [lindex $args 0] -> foo _bar] {
upvar $foo _foo
# if it is array...
if [-a _foo] {return $_foo($_bar)}
# and if it is list...
return [lindex $_foo $_bar]
}

Goal:

% array set test {a 1 b 2 c 3 d 4}
% puts [test:a]
1 % puts [test:b]
2

How is writing [test:a] better than $test(a)?

It's better when 'test' is a variable (probably in a loop) whose value
is the name of an array (looping through a list of arrays) and I can write

[$test:a]

instead of

[set $test(a)]

especially when I want to access that array in the global scope from inside
a proc, which in proper Tcl would be

[set ::${::test}(a)]

Yikes!

But my proc often fails inside procs. Not always, but often, which puzzles me.

Is this practice dangerous? Why? Is there a better way?

I am using the yikes! method for now because it's safer, but I think it's a
monstrosity and really wish I could use a cleaner syntax.

Note I only use my overloaded 'unknown' proc and interp aliases in scripts
that I'm sure will never be shared.

--
Luc
>>

* Luc <no@no.no>
| It's better when 'test' is a variable (probably in a loop) whose value
| is the name of an array (looping through a list of arrays) and I can write
>
| [$test:a]
>
| instead of
>
| [set $test(a)]

Or rather [set ${test}(a)] if $test is the *name* of the array.

| especially when I want to access that array in the global scope from inside
| a proc, which in proper Tcl would be
>
| [set ::${::test}(a)]

IMHO the proper TCL way would be using upvar:

proc foo {global_arrayname} {
upvar \#0 $global_arrayname foo
puts "a in global array $global_arrayname is {$foo(a)}"
}
$ foo x
can't read "foo(a)": no such variable
$ array set x { a 1 b 2 }
$ foo x
a in global array x is {1}

R'

Luc <no@no.no> wrote:
> I think I lifted this from wikit many winters ago:
>
> # lists and arrays with sugar
> set rgx {([0-9A-Za-z_]+):([0-9A-Za-z_]+)$}
> if [regexp $rgx [lindex $args 0] -> foo _bar] {
> upvar $foo _foo
> # if it is array...
> if [-a _foo] {return $_foo($_bar)}
> # and if it is list...
> return [lindex $_foo $_bar]
> }
>
>
> Goal:
>
> % array set test {a 1 b 2 c 3 d 4}
> % puts [test:a]
> 1
> % puts [test:b]
> 2
>
>
> How is writing [test:a] better than $test(a)?

Some possible reasons:

1) code golf -- just to show the syntax flexibility of TCL;

2) for someone with a keyboard set for a non-english locale, possibly [
] and : are easier to type than $ ( and ) ?

On 12/21/2022 12:31 PM, Rich wrote:
> Luc <no@no.no> wrote:
>> I think I lifted this from wikit many winters ago:
>>
>> # lists and arrays with sugar
>> >> How is writing [test:a] better than $test(a)?
>
> Some possible reasons:
>
> 1) code golf -- just to show the syntax flexibility of TCL;
>
> 2) for someone with a keyboard set for a non-english locale, possibly [
> ] and : are easier to type than $ ( and ) ?
>

Another point, which I suspect is more likely, is this:

It tries to normalize both array and list retrievals, to make them look
identical. So, [var $x] and [lindex $var $x] are uniformly written as
[$var $x]. In some cases, this may be a useful abstraction, despite the
an additional proc call for each such access.

On 12/21/2022 1:17 PM, saitology9 wrote:
> Another point, which I suspect is more likely, is this:
>
> It tries to normalize both array and list retrievals, to make them look
> identical.  So, [var $x] and [lindex $var $x] are uniformly written as

The last sentence should read:

"So, $var($x) and [lindex $var $x] are uniformly written as"