Forum: Ruby function inside a function

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.
Jason L. (Guest)
on 2009-01-28 17:51
I have a question about the timing of function evaluations in this case:

def function_a(x = 1)
  x**2 + x
end

def function_b(any_function)
  y = 4 + 5 #this would actually be more complex
  function_a(y)
end

puts function_b(function_a)

I found that function_a(x = 1) is evaluated first, then
function_b(function_a). I found that 'def function_a(x = nil) returns an
error. Why does function_a need to be evaluated before it is called as
an argument in function_b?

PS - the reason I am writing things this way is to make function_b
accept any function (within reason).
Jesús Gabriel y Galán (Guest)
on 2009-01-28 18:35
(Received via mailing list)
On Wed, Jan 28, 2009 at 4:49 PM, Jason L.
<removed_email_address@domain.invalid> wrote:
>
> puts function_b(function_a)
>
> I found that function_a(x = 1) is evaluated first, then
> function_b(function_a). I found that 'def function_a(x = nil) returns an
> error. Why does function_a need to be evaluated before it is called as
> an argument in function_b?

The problem here is that when you write function_a, this is actually
*calling* function_a,which as you are not supplying any parameter uses
the default value of 1 you defined.

> PS - the reason I am writing things this way is to make function_b
> accept any function (within reason).

For sure there are many ways to achieve this, but a common way is to
use blocks and lambdas:

function_a = lambda {|x| x**2 + x}

def function_b
  y = 4 + 5 #this would actually be more complex
  yield y
 end

or more explicitly:

def function_b (&blk)
  y = 4 + 5
  blk.call(y) # or blk[y]
end

puts function_b(&function_a)

Hope this helps,

Jesus.
Ruben M. (Guest)
on 2009-01-28 18:45
(Received via mailing list)
In ruby, function_a is a method call (with no arguments), and as a
call, it gets evaluated to whatever that function returns. If you
wanted to grab the function as a "pure function", you'd use lambdas or
Procs like Jesús pointed.

In other words:

function_a = Proc.new {|x| ..do something with x... }

returns a functional object. You can then call the method with
function_a.call (aliased [])

see http://www.ruby-doc.org/core/classes/Proc.html for details on Proc
objects


Greetings

On Jan 28, 9:49 am, Jason L. <removed_email_address@domain.invalid>
Jason L. (Guest)
on 2009-01-28 19:45
Perfect. Thank you!
Brian C. (Guest)
on 2009-01-28 21:04
Ruben M. wrote:
> In ruby, function_a is a method call (with no arguments), and as a
> call, it gets evaluated to whatever that function returns. If you
> wanted to grab the function as a "pure function", you'd use lambdas or
> Procs like Jes�s pointed.
>
> In other words:
>
> function_a = Proc.new {|x| ..do something with x... }
>
> returns a functional object. You can then call the method with
> function_a.call (aliased [])

Or, if you really want to do this with def'd methods, you can use

   obj.method(:function_a)

which will turn an existing method (bound to the instance 'obj') into a
Proc-like thing that you can pass around and call later.

def function_a(x = 1)
  x**2 + x
end

def function_b(any_function)
  y = 4 + 5
  any_function.call(y)   # or: any_function[y]
end

puts function_b(method(:function_a))
This topic is locked and can not be replied to.