Forum: Ruby executing a block in the context of receiver

Announcement (2017-05-07): www.ruby-forum.com is now read-only since I unfortunately do not have the time to support and maintain the forum any more. Please see rubyonrails.org/community and ruby-lang.org/en/community for other Rails- und Ruby-related community platforms.
Mark V. (Guest)
on 2006-03-14 17:21
(Received via mailing list)
In the following code the do_this instance method of the foo object
calls yield to run the block that is passed to it.

foo.do_this(p1, p2) {
  do_that(p3, p4)
}

Is there any way to make it so that do_that is executed in the context
of the foo object, i.e. it acts as though it was invoked with
foo.do_that(p3, p4)?  I know I could just say "foo.do_that(p3, p4)",
but I was wondering if I could avoid that.
Ross B. (Guest)
on 2006-03-14 17:42
(Received via mailing list)
On Wed, 2006-03-15 at 00:20 +0900, Mark V. wrote:
> but I was wondering if I could avoid that.
If you're writing 'foo' then you can do:

	class Foo
	  def do_this(&blk)
	    instance_eval &blk
	  end

	  def do_that
	    puts "Doing that..."
	  end
	end

	f.do_this { do_that }
	# (prints) Doing that...

	# can use this form, too
	f.do_this { |foo| foo.do_that }
	# (prints) Doing that...

There's a few subtleties to using instance_eval you might want to look
up, but maybe it does the job...
unknown (Guest)
on 2006-03-15 22:40
(Received via mailing list)
Also,
send(:do_that, p3, p4)
unknown (Guest)
on 2006-03-15 22:58
(Received via mailing list)
Hi --

On Wed, 15 Mar 2006, Ross B. wrote:

>> foo.do_that(p3, p4)?  I know I could just say "foo.do_that(p3, p4)",
> 	    puts "Doing that..."
> 	  end
> 	end
>
> 	f.do_this { do_that }
> 	# (prints) Doing that...
>
> 	# can use this form, too
> 	f.do_this { |foo| foo.do_that }
> 	# (prints) Doing that...

But only if you yield self from do_this (just to clarify).  And
initialize f, but I guess that was implied :-)

I like the second form better.  Just having self change mysteriously
for the duration of a block always strikes me as a bit of an
obfuscation.


David

--
David A. Black (removed_email_address@domain.invalid)
Ruby Power and Light, LLC (http://www.rubypowerandlight.com)

"Ruby for Rails" chapters now available
from Manning Early Access Program! http://www.manning.com/books/black
Ross B. (Guest)
on 2006-03-16 00:08
(Received via mailing list)
On Thu, 2006-03-16 at 05:57 +0900, removed_email_address@domain.invalid wrote:
> >> }
> > 	    instance_eval &blk
> > 	# can use this form, too
> > 	f.do_this { |foo| foo.do_that }
> > 	# (prints) Doing that...
>
> But only if you yield self from do_this (just to clarify).  And
> initialize f, but I guess that was implied :-)
>

(Oops, overzealous cut/paste job :) )

Probably irrelevant, but from what I can gather, instance_eval will pass
the new self in as a block parameter, too:

	Object.new.instance_eval { |me| self == me }
	# => true

Though this doesn't seem to be documented...?

> I like the second form better.  Just having self change mysteriously
> for the duration of a block always strikes me as a bit of an
> obfuscation.
>

I like instance_eval for those cool DSL style things, but usually I'm
with you on that one.
unknown (Guest)
on 2006-03-16 00:21
(Received via mailing list)
Hi --

On Thu, 16 Mar 2006, Ross B. wrote:

> Probably irrelevant, but from what I can gather, instance_eval will pass
> the new self in as a block parameter, too:
>
> 	Object.new.instance_eval { |me| self == me }
> 	# => true
>
> Though this doesn't seem to be documented...?

Interesting -- definitely relevant, too, in the sense that my
correction was wrong.  I don't remember seeing that documented either.


David

--
David A. Black (removed_email_address@domain.invalid)
Ruby Power and Light, LLC (http://www.rubypowerandlight.com)

"Ruby for Rails" chapters now available
from Manning Early Access Program! http://www.manning.com/books/black
This topic is locked and can not be replied to.