Re: All the way up or current scope

[Oliver Kiddle <opk@xxxxxxx>]

On 12 May, Bart Schaefer wrote:
> As I said earlier in this thread, we tried a pointer implementation
> and never got as far as what's now done.  It ended up requiring
> reference counting.  I believe Oliver still has the partly-finished
> code for that variation somewhere.

The main challenge with the pointer implementation was not the reference
counting but the various places in the code where zsh was causing the
pointer to be invalid such as by removing it and creating it anew when
changing a parameter's type. I did have fixes to most such cases and if
you think there's value in such refactorings, they could be resurrected.
The way that private variables are implemented also broke it and the
last time I rebased that code was sometime before they were added.
Reference counting would allow a local variable that has a reference
to persist after the scope ends which would have some interesting uses
but the current implementation enables other more useful things like
references to subscripts. While experimenting with reference counting I
repeatedly had nagging doubts about the wisdom of the approach and don't
for a moment think we should be considering it now that we have a decent
alternative implementation working.

I've not been in a position to try the latest patches and haven't
followed every word of the discussion but just to put in my thoughts on
some of the main points:

typeset -nu always being relative to declaration does seem to be the
most logical, sensible and useful behaviour. I believe this is what has
now been implemented and pushed.

Fixing typeset -n to the current scope (applying the -u0 Philippe
suggested by default) would seem counterintuitive to me. With the
default of dynamic scoping, I'm used to being able to just use variables
from parent scope. Digging into parent scopes should always be very much
explicit.

I can see the potential uses of being able to specify -u0 or -u2.
But I certainly agree with Bart that it would be better to get a new
release out sooner without more new inventions. Using numeric counts
seems somewhat ugly and you should have the effect of -u2 by creating
a -un reference to a -un reference. Only problem is there's no way
to change the second of those references given the name of the first
reference. With a reference passed to a for loop where that reference
is a reference to another reference, it could follow to the end of the
reference chain and iterate the final reference. Whether that reference
was defined with -u or not would determine the scope for each target in
the for loop.

Oliver