Passing two functions as parameters

Ruby
1

Is it possible to pass a function as a parameter?

I want to do something like this:

def my_fnc1
end

def my_fnc2
end

def call_fncs( function1, function2 )

#call function1
#call function2
end

#call call_fncs( my_fnc1, my_fnc2 )

Turing.

2

I know only one way:

call_fncs( Proc.new { my_fnc1 }, Proc.new { my_fnc2 } )

and in call_fncs:

function1.call
function2.call

But then I can just use a block and pass as first param a flag which
indicates which function should be called. This would be not so clean,
but I could avoid the two block inside the parameter list and have one
after the function call.

Turing

3

On Aug 16, 12:40 pm, Frank M. [email protected] wrote:

Is it possible to pass a function as a parameter?

irb(main):001:0> def hi; puts “hello”; end
=> nil
irb(main):002:0> def earth; puts “world”; end
=> nil
irb(main):003:0> def do2( f1, f2 )
irb(main):004:1> f1.call
irb(main):005:1> f2.call
irb(main):006:1> end
=> nil
irb(main):007:0> do2( method(:hi), method(:earth) )
hello
world
=> nil

See also lambda and Proc.new for defining anonymous functions on the
fly.

4

Gavin K. wrote:

On Aug 16, 12:40 pm, Frank M. [email protected] wrote:

Is it possible to pass a function as a parameter?

irb(main):001:0> def hi; puts “hello”; end
=> nil
irb(main):002:0> def earth; puts “world”; end
=> nil
irb(main):003:0> def do2( f1, f2 )
irb(main):004:1> f1.call
irb(main):005:1> f2.call
irb(main):006:1> end
=> nil
irb(main):007:0> do2( method(:hi), method(:earth) )
hello
world
=> nil

See also lambda and Proc.new for defining anonymous functions on the
fly.

Thank you that’s exactly what I need.

Turing.

5

[mailto:[email protected]] On Behalf Of Frank M.

Subject: Re: Passing two functions as parameters

I know only one way:

call_fncs( Proc.new { my_fnc1 }, Proc.new { my_fnc2 } )

i like ruby since it treats vars and methods alike.

this is just a simple example,

irb(main):001:0> def x
irb(main):002:1> puts “x”
irb(main):003:1> end
=> nil
irb(main):004:0> def y
irb(main):005:1> puts “y”
irb(main):006:1> end
=> nil
irb(main):007:0> def test(x,y)
irb(main):008:1> x
irb(main):009:1> y
irb(main):010:1> end
=> nil
irb(main):011:0> test x,y
x
y
=> nil
irb(main):012:0> def test2(a=x,b=y,c=x)
irb(main):013:1> a
irb(main):014:1> b
irb(main):015:1> c
irb(main):016:1> end
=> nil
irb(main):017:0> test2
x
y
x
=> nil
irb(main):018:0>

kind regards -botp

6

I don’t think what you are doing is valid code. Ruby is call by value so
the
arguments to a method
get evaluated before anything happens. If your x method takes an
argument
then your code won’t
work.

7

Is it possible to pass a function as a parameter?

You can pass a block:

kall_funk(&funk)

If you want to do the functional programming thing of feeding a
function to a function to a function, it’s doable, but I don’t recall
how off the top of my head. There’s a great set of chapters on this in
a book called “Ruby By Example,” though. “Ruby By Example” is a very
very mis-titled book. It should really be called “An Introduction To
Ruby Which Emphasizes Functional Programming” but that title would
have been a bit unwieldy.

Anyway, I know what you want to do is essentially possible, although
it sometimes looks a bit odd.

–
Giles B.

Blog: http://gilesbowkett.blogspot.com
Portfolio: http://www.gilesgoatboy.org

8

On Aug 16, 8:00 pm, Peña, Botp [email protected] wrote:

irb(main):005:1> puts “y”
y
x
=> nil

You may not realize it, but what you just wrote is the same as:
def test2( a=x, b=y, c=x )
nil
nil
nil
end

The methods are being invoked as the method parameters are being set
up, and three nil values (the return value of those methods, which is
the return value of their ‘puts’ calls) are being assigned to your
variable. I only point this out since the code sort of implies that
the parameter assignments are treating methods as first-class
functions, and you are invoking them inside the method.

9

From: david karapetyan [mailto:[email protected]]

I don’t think what you are doing is valid code. Ruby is call

by value so the arguments to a method

get evaluated before anything happens. If your x method takes

an argument then your code won’t work.

arggh, what was i thinking :frowning: i need a ptr to the fxn in ruby.
you are right, of course.
kind regards -botp

10

On Behalf Of Frank M.:

I know only one way:

call_fncs( Proc.new { my_fnc1 }, Proc.new { my_fnc2 } )

and in call_fncs:

function1.call

function2.call

But then I can just use a block and pass as first param a flag which

indicates which function should be called. This would be not

so clean, but I could avoid the two block inside the parameter list

and

have one after the function call.

ok, let me take a second shot (and my apology to my previous post).

i find when doing thing like this in ruby, you should think about
blocks, block, it’s blocks everywhere. blocks allows one to think (in a
cleaner) way between being oo-oriented or fxn-oriented.

when in ruby, i think pass object, when in javascript, i think pass fxns
(yes, yes, i drunk too much javascript last month; hey is passing fxns
in javascipt really addictive? :slight_smile:

anyway, this is another simple example. hopefully, this time i am
correct :slight_smile:

irb(main):001:0> def x
irb(main):002:1> puts “x”
irb(main):003:1> “x”
irb(main):004:1> end
=> nil
irb(main):005:0> def y
irb(main):006:1> puts “y”
irb(main):007:1> “y”
irb(main):008:1> end
=> nil
irb(main):009:0>
irb(main):010:0* def test(p1=lambda{x},p2=lambda{y},p3=p1)
irb(main):011:1> p1.call + p2.call + p3.call
irb(main):012:1> end
=> nil
irb(main):013:0> test
x
y
x
=> “xyx”

hmmm, no surprises there. but you’re right, it isn’t so clean…

so let’s introduce blocks,…

irb(main):014:0> def test2
irb(main):015:1> yield
irb(main):016:1> end
=> nil
irb(main):018:0> test2 {x}
x
=> “x”
irb(main):019:0> test2 {y}
y
=> “y”

hmmm, not bad. I didn’t declare any lambda or proc in there… very
clean… it’s as if yield is doing something additional job for me (and i
like it) …

now, let’s see if we can so some ala fxnal styles using blocks,…

irb(main):035:0* def test3 p1=:x
irb(main):036:1> if p1 == :x
irb(main):037:2> test2 {x}
irb(main):038:2> else
irb(main):039:2* test2 {y}
irb(main):040:2> end
irb(main):041:1> end
=> nil
irb(main):042:0> test3
x
=> “x”
irb(main):043:0> test3 :y
y
=> “y”

hmmm, not bad…
but can we skip the test2 call so we can be “more” fxnal, so to speak ?
… ok

irb(main):044:0> def test4 p1=:x
irb(main):045:1> if p1 == :x
irb(main):046:2> yield lambda{x}
irb(main):047:2> else
irb(main):048:2* yield lambda{y}
irb(main):049:2> end
irb(main):050:1> end
=> nil
irb(main):051:0> test4 {|a| a.call}
x
=> “x”
irb(main):052:0> test4(:y) {|a| a.call}
y
=> “y”
irb(main):053:0>

Is that ok?
kind regards -botp

11

Thanks for all your work, but unfortunately when I created this topic I
didn’t realize that I cannot use blocks, because I’m passing a Hash to
this constructor which consists of a symbol/string/whatever which maps
to an array of two functions.

So a call would look like this:

r = MyClass.new(
:symbol1 => [ method( :foo ), method( :bar ) ],
:symbol2 => [ method( :foo2 ), method( :bar2 ] ) #and so on

These functions are used to convert from a given object (can be anything
it’s up to the user) to a known object type and back to a user object.