On Sunday 23 November 2003 07:12 pm, Mathieu Bouchard wrote:

> I'm puzzled by how this new behaviour would make anything actually easier
> for anyone, while demanding significant workarounds for code that relies
> on having separate locals for multiple activations of a closure.

Actually I agree. I don't know why Matz thinks this is the "most regrettable 
behavior in Ruby". To me it makes perfect sense --a varaible is visible in 
the scope it was defined and all inner "sub"-scopes. How can you get any more  
POLS then that? I'd even take it further and make "instance varaibles" work 
likewise (but that's another story). Sure, you have to define a dummy 
variable on the outside of block to get it to come out the other end, but 
that's exactly becuase that's the scope level you want it to exist in --sort 
of self documenting.

> Unless I'm really missing something big (please tell me!), it seems to be
> about on the same level as my proposed merging of Module and Class, except
> that my proposal didn't have such an obvious compatibility impact.

Well I don't think so, but I'm crazy so.... I think there's just some 
irrational distaste for i = nil at the root of this (no one likes to have 
nothing ;)

So what's this merging of Module and Class all about?

> > p.s. if you don't mind me asking, what do you think of Structural
> > Reflection?
>
> never heard about it, though the words do sound familiar. what is it?

Refelection is when code can look at itself (inspection) and also manipulate 
itself. So Ruby has reflection at the OO level. It's one of the greatest 
things about Ruby. Structural reflection is a step or two lower, where a 
language can actually manipulate its own statements, yet is still a rung or 
two above on-the-fly syntax manipulation. Here's a pseudo example:

  def m
    print "A"
    print "B"
  end

  m; puts >> "AB"

  puts m:[0].to_s  # => print "A"
  puts m:[1].to_s  # => print "B"
  m: << lambda { print "C" }

  m; puts >> "ABC"

The colon notation used here to refer to the method "structure" of m is 
completely made up, but you get the idea. With structural reflection, I can 
manipulate the code on-the-fly as if it were an array of statements, for 
example.

Actually, Ruby does have some *limited structural reflection* through the use 
of eval.

-t0