[ruby-talk:00545] Proc calls with variable context?

Hi,

I have another question...

There is a method `eval' for that you can deliver a `Binding'
instance. Unfortunately, the `eval' method seems only to work with
`String' instances, not mit `Proc' instances.

Could we get a new method called e.g. `bound_call' for class `Proc'
that would like to get a `Binding' or another `Proc' instance. The
instance to be called would be executed under the context contained
in the other `Proc' instance or the `Binding' instance!

So that could be possible:

	class Bind
	   def binding
	      binding
	   end
	end

	class Foo < Bind
	   @var = "(not init)"
	end

	class Bar < Bind
	   @var = "(default)"
	   def show
	      print "show #{@var}\n"
	   end
	end

	fn = proc{ |what| print "The #{what} is `#{@var}'\n" }

	foo = Foo.new
	bar = Bar.new

	barbind = bar.binding
	foobind = foo.binding

	fn.bound_call(barbind, "value")
=> The value is `(not init)'

	fn.bound_call(foobind, "whatever")
=> The whatever is `(default)'

	mshow = bar.method :show
	pshow = mshow.to_proc

	pshow.bound_call(foobind) 
=> show `(not init)'

What do you think about it?

\cle