instance_eval/instance_exec discussion

Introduction:

At RubyConf, matz talked about introducing a new method 'instance_exec'. I
understood its purpose was to provide a way to pass arguments to
instance_eval. If this is not the case stop me here :)

Assuming that this _is_ the case, I'd like to introduce a pure-ruby
implementation for instance_eval that allows for passing arguments to
instance_eval. It's not anything special, but I thought I would bring it up
for discussion.

Implementation:

class Object
alias __instance_eval__ instance_eval
def instance_eval(*args, &block)
if block.nil?
__instance_eval__(*args)
else
(class<<self;self end).send(:define_method, :__inst_eval_temp__, block)
result = __inst_eval_temp__(*args)
if respond_to? :__inst_eval_temp__
(class<<self;self end).send(:remove_method, :__inst_eval_temp__)
end
result
end
end
end


Analysis:

Essentially, this new version works exactly like the original, except that
when a block is given, the method arguments are passed into the block as
block arguments.

It does so by using the given block to define a temporary method. The
temporary method is invoked with the arguments to the block. The temporary
method is then immediately removed, if it hasn't been already by a recursive
call to instance_eval on the same object.

This implementation is thread-safe because the temporary method is defined
on the singleton class of the object (aka 'metaself' as Dave Thomas called
it at RubyConf 2005).


Purpose:

I'm not proposing to make this a part of ruby. My purpose is to:

1) Post a pure-ruby version of instance_eval that allows for block
arguments. I find it useful and others might also.

2) Show that (possibly) there is no need for instance_exec, because
instance_eval can quite simply be modified to allow for block arguments. The
real implementation should be in C, and would use a much less hackish
approach.

If this idea were received positively, I would spend the time looking into
writing a better C implementation.


Dan Amelang