Re: easy calling of associative array?

[Ray Andrews <rayandrews@eastlink.ca>]

On 11/01/2015 10:51 PM, Bart Schaefer wrote:
> Anyway, that's actually the point.  ${(P)ref} resolves to the values of
> the array, and then the subscript is applied.  Ask yourself: what are
> "the values of" an associative array, in every other context?
I'll give it some time, this is new to me.  It seems that with an 
associative array,
what we have is some 'hidden' syntax, IOW there is a sort of shorthand going
on.  As with math, I'd sorta expect that if this functionality was 
tacked on
after the fundamentals of the shell were already in place--you leveraged
what was there--there'd be asymmetries.

Experimenting with trying to make accessing associative arrays convenient:

    echo_v ()
    {
    echo ${(P)${:-${1}[$2]}}    #this works
    #eval "echo \$${1}[$2]"     #and this works too.
    }

    get_v ()
    {
    #$3=${(P)${:-${1}[$2]}}     #nothing works
    eval "$3=\$${1}[$2]"        #this works
    }

    set_v ()
    {
    # {(P)${:-${1}[$2]}}=$3       #nothing works
    eval "${1}[$2]=$3"            #this works
    }

    test_v ()
    {
    #eval "${1}[$2]"            #nothing works
                                 #this works
    [ ${(P)${:-${1}[$2]}} = $3 ] && echo 'all too true' || echo 'alas, no.'
    }


I notice that with 'echo_v' I can use your syntax or 'eval' the thing 
which is
much easier to read if nothing else.  But with 'get_v' and 'set_v' I can 
only make
it work with 'eval' whereas with 'test_v' I can *not* make it work with 
'eval'.
At the risk of being too much of a symmetry nut, is it possible to make 
either
form work in all the above situations?  If so, I have a consistent 
interface to
these arrays which would be pleasing, but it's an academic point.

FWIW, this is in the context of studying Sebastian's stuff--there's all 
these
variables sloshing about for each of several zcurses windows, and it 
would be
C-ish to organize them into arrays, one for each window.  However I can
see that this is at the limits of what a shell should be asked to do, since
what I really want is a proper C structure for data:

main_window.window_height

becomes:

${main_window[window_height]}

... but of course I want to be able to replace 'main_window' with
any other window via a variable passed to whatever function:

whatever_window->window_height

becomes:

${(P)${:-${whatever_window}[window_height]}}

... which looks like it's going to work just so long as I can perform 
any sort
of operation on the array without difficulty. But there could be speed 
issues
and the whole thing might not be worth the trouble, but it is educational
at least.