I'm considering writing a RCR. To assess the interest of doing so and
present it in a clearly understandable way, I need some 'field data'
regarding typical expectations and usage patterns. I cannot use "my
POLS" as an argument, but I can argue that some behaviour requires lower
'brain power consumption' for xx% users over a given sample, or that it
works better given some typical usage pattern.

I'd appreciate if you answered the following questions (answers are always
yes/no unless specified otherwise):


(1) Would you expect the following snippet to work (that is, print '1')?
def make_closure
  ret = proc{ |a| eval "#{a}" }

  local = 1
  ret
end

puts make_closure["local"]


(2) Do you want the above to work, i.e. do you *need* that (based on the
programs you have written so far, not on hypothetical future use cases)?


(3) Do you know why the following won't work (the finalizer will never
    be called)?

class A
  def initialize
    ObjectSpace.define_finalizer(self, 
      proc { |id| puts "#{id} collected" })
  end
end
A.new


(4) Have you ever wished the above worked?


(5) Do you register blocks/Procs meant to be used as callbacks/stored
for later usage? How often (from 0 to 10, 10 being 'yes, all the time'
and 0 'never, ever')?


(6) Have you ever done something like the following? How often (from 0 to 10,
10 being 'yes, all the time' and 0 'never, ever')?

def some_method(filename)
  data = File.read(filename)    # or any method creating large objects, meant
                                # to be temporary.
  ....                          # process data
  proc do 
    .... things not using data directly, but byproducts from the above
    processing, i.e. data is not explicitly referenced here ....
  end 
  # alternatively, instead of returning a Proc, passing it to some other
  # method that might keep it for later use
end


Please return me your answers via IRC irc.freenode.net #ruby-lang (nick
batsman(\|.*)? or similar) or by email at

batsman dot get at yahoo dot com

Thanks.