[ruby-talk:5794] Re: local variables (nested, in-block, parameters, etc.)

ts wrote:
> 
> >>>>> "G" == Guy N Hurst <[e-mail]> writes:
> 
>  The scope of a variable is determined at *compile time*
> 

I admit I am mainly focusing on programmer interface, not
compiler programming aspects...
But the compiler should be able to be made to recognize the 
scope of |x~|.

> G> x=9;
> 
>   local variable
> 
> G> [1,2,3].each{|x~| break if x==2}
> 
>   dynamic variable
>
> G> p x  #-> 9
> G> p {}::x      #-> 2
> 
>  sorry you have lost the dynamic variable.
>

I admit that to implement this scope thing would require that certain
dynamic variables be kept, at least until the next block... 

 
> G> Alternatively, I suppose the same tilde thing could be used for that, too.
> 
> G> x=9;
> G> [1,2,3].each{|x~| break if x==2}
> G> p x  #-> 9
> G> p x~ #-> 2
> 
>  in this case initialize y (rather than x~) before the each.
> 

But that is precisely what I am trying to avoid ;-)

By explicitly using a tilde, I hope to make Ruby understand how I
plan to use that variable, and do the assignment for me, if applicable.


> G> {|x,y|<a,b> a=x; ....}       # <a,b> in-block only
> 
>  Something like this :
> 
> pigeon% cat b.rb
> #!./ruby
> a = 1
> b = 2
> p "#{a} -- #{b}"
> [[3, 4]].each do <a> |b|
>       p "#{a} -- #{b}"
> end
> p "#{a} -- #{b}"
> pigeon% b.rb
> "1 -- 2"
> "3 -- 4"
> "1 -- 4"
> pigeon%
> 

Ok, but I still have to know about all local variables.
I have make sure 'a' is not already used elsewhere before I define 
it to be a=1.


> G> p {}::a                      # but still accessible outside ;-)
> 
>  You can't do this I think.
> 

Not currently, as you skillfully pointed out.
But that is a proposed capability...


> G> I don't think the tilde is so bad, considering its capability...
> 
>  You have not resolved the proposition (2), i.e. a *real* 'let' which create a
>  block (without a NODE_ITER). My proposition do() is the equivalent of 'let'
> 

Alas, I think my understanding fails here...

I think I did resolve (2), at least from an interface perspective.
(I am no compiler programmer, although it looks interesting)

The concept of using |x~| basically says to use a copy of 'x' locally.
This is so I do not have to know whether x already exists or not.
The idea of <a> is good, too, but I think the assignment should be
built-in.


>  With
> 
>   [[3, 4]].each do <a> |b|
>       p "#{a} -- #{b}"
>   end
> 
>  *and*
> 
>   do a = a + 2
>   end
> 
>  You have the proposition (1) *and* the proposition (2)
> 
>  I've still not understood the proposition (3) :-(
> 
>  proc = lambda(a, b)
>  end
> 
>  Is this a NODE_ITER or NODE_DEFN (with NODE_ARGS and NODE_SCOPE) ?
> 

And this transcends my knowledge now.

I can see you are much more advanced than I, and know the source well.

Thanks for your reply  :-)


Guy N. Hurst



-- 
HurstLinks Web Development    http://www.hurstlinks.com/
Norfolk, VA - [phone]
PHP/MySQL - Ruby/Perl - HTML/Javascript