function inside a function

[Jason Lillywhite]

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]

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?

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.

 

[Rubén Medellín]

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

 

[Jason Lillywhite]

Perfect. Thank you!

 

[Brian Candler]

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.methodfunction_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(methodfunction_a))