Forum: Ruby how to use a proc like a method

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.
91f93d595503b98f18207fc95d66b573?d=identicon&s=25 hochherz (Guest)
on 2005-12-19 21:59
(Received via mailing list)
is there a way to use a proc like a method?

like:

class A
   def initialize
     @av=10;
   end
   def do(mproc)
     mproc.call();
   end
   def rt()
     @av;
   end
end


a=proc{@av=111} #something different
b=A.new
b.do(a)
b.rt #return -> 111

is it possible by makeing subclass of proc to do this?
Cff9eed5d8099e4c2d34eae663aae87e?d=identicon&s=25 Jacob Fugal (Guest)
on 2005-12-19 22:09
(Received via mailing list)
# ------------ 8< ------------

class A
  def initialize
    @av=10;
  end
  def do(mproc)
    #### changed this line ####
    instance_eval &mproc
  end
  def rt()
    @av;
  end
end

a=proc{@av=111} #something different
b=A.new
b.do(a)
b.rt #return -> 111

# ------------ 8< ------------

Jacob Fugal
Cff9eed5d8099e4c2d34eae663aae87e?d=identicon&s=25 Jacob Fugal (Guest)
on 2005-12-19 22:21
(Received via mailing list)
Now that I answered the simple questions, I'd suggest some style
changes/fixes:

# ------------ 8< ------------

class A
  def initialize
    @av = 10 ### [1], [2]
  end
  def do(&mproc) ### [3]
    instance_eval &mproc
  end
  def rt ### [4]
    @av
  end
end

a = proc{ @av = 111 } # something different
b = A.new
b.do(&a) ### [5]
b.do { @av = 111 } ### [6]
b.rt # return -> 111

# ------------ 8< ------------

[1] Ruby doesn't need a semicolon. The newline is the statement
separator. A semicolon can be used to separate multiple statements on
the same line, however.

[2] Be liberal with your whitespace. This is simply style, but I think
you'll find most rubyists share this preference.

[3] You can make a method accept a block parameter (such as Array#each
does) by prepending the last parameter in the parameter list with an
ampersand (&).

[4] If you are defining a method with no parameters, it's acceptable
to leave off the empty parentheses. This is also just style and may be
debated.

[5] You can change a Proc object into a block with the & prefix. (In
fact, you can turn any object into a block with & and a properly
defined to_proc method. Whether doing so is good practice is
debatable.)

[6] The obvious alternative to creating an explicit proc then
converting that proc to a block.

Jacob Fugal
E7559e558ececa67c40f452483b9ac8c?d=identicon&s=25 unknown (Guest)
on 2005-12-19 23:12
(Received via mailing list)
On Dec 19, 2005, at 4:19 PM, Jacob Fugal wrote:
> [5] You can change a Proc object into a block with the & prefix. (In
> fact, you can turn any object into a block with & and a properly
> defined to_proc method. Whether doing so is good practice is
> debatable.)

This doesn't seem quite accurate to me.  The expression generated
by the use of '&' in a method call is an instance of Proc.  If the
expression prefixed by '&' is already an instance of Proc then
no conversion of any type occurs, the object is passed 'as is' to
the method.

If might be more accurate to say:

Instead of using a literal block in a method call, you can arrange
for any object to be passed as the 'block argument' to the method
with the '&' prefix operator:

	method(arg1, arg2, arg3, &block_arg)

If 'block_arg' is not an instance of Proc, then block_arg.to_proc
is called and the result, which must be an instance of Proc, is
passed to the method instead.
Cff9eed5d8099e4c2d34eae663aae87e?d=identicon&s=25 Jacob Fugal (Guest)
on 2005-12-20 00:01
(Received via mailing list)
On 12/19/05, gwtmp01@mac.com <gwtmp01@mac.com> wrote:
> no conversion of any type occurs, the object is passed 'as is' to
> If 'block_arg' is not an instance of Proc, then block_arg.to_proc
> is called and the result, which must be an instance of Proc, is
> passed to the method instead.

That's very true and accurate. Thanks for the clarification. My
original intent was to say "You can [pass] a Proc object into a block
[argument] with the & prefix." The type of the object doesn't change,
just the passing semantics. And, "In fact, you can turn any object
into a [Proc with block argument semantics] with & and a properly
defined to_proc method." Careless terminology and lack of
proofreading, my apologies.

Jacob Fugal
This topic is locked and can not be replied to.