Pass References To Methods As Arguments?


#1

Hey all. I am trying to determine the Ruby syntax for passing a
reference
to a method. I want to actually pass the reference itself as an argument
to
another method.

Consider the following simplified Perl example. It features two
subroutine
functions and another subroutine that is capable of calling any
subroutine
passed to it as a reference.

sub print_unix_line {
print shift, “\n”
}

sub print_windows_line {
print shift, “\015\012”;
}

sub call_a_routine {
my ($routine, $argument) = @_;
$routine->($argument);
}

&call_a_routine(&print_unix_line, ‘Hello, unix World!’);
&call_a_routine(&print_windows_line, ‘Hello, Windows World!’);

The “&” prefixed parts are references to subroutines. I have tried to
recreate this logic in Ruby using Proc blocks, but I can’t get it to
work
properly. Any suggestions?


#2

On 26/01/06, wegzumir removed_email_address@domain.invalid wrote:

Hey all. I am trying to determine the Ruby syntax for passing a
reference to a method. I want to actually pass the reference itself as
an argument to another method.

There is no way to do that directly in Ruby.

}

sub call_a_routine {
my ($routine, $argument) = @_;
$routine->($argument);
}

&call_a_routine(&print_unix_line, ‘Hello, unix World!’);
&call_a_routine(&print_windows_line, ‘Hello, Windows World!’);

Your example really isn’t a good one, but:

print_unix_line = lambda { |arg| print arg + “\n” }
print_wind_line = lambda { |arg| print arg + “\015\012” }

def call_a_routine(routine, argument)
routine[argument]
# or: routine.call(argument)
end

call_a_routine(print_unix_line, “Hello, unix.”)
call_a_routine(print_wind_line, “Hello, Windows.”)

class Routines
def print_unix_line(arg)
print arg + “\n”
end

def print_wind_line(arg)
  print arg + "\015\012"
end

end

def call_a_routine(routine, argument)
@@routine ||= Routines.new
@@routine.send(routine, argument)
end

call_a_routine(:print_unix_line, “Hello, unix.”)
call_a_routine(:print_wind_line, “Hello, Windows.”)

As far as the poorness of the example you have, you don’t need to do
anything special with Ruby to print properly:

puts “Hello Ruby, World”

What exactly are you really trying to do?

-austin


#3

On Jan 26, 2006, at 5:41 PM, wegzumir wrote:

passed to it as a reference.

sub print_unix_line {
print shift, “\n”
}

def print_unix(line)
print “#{line}\n”
end

sub print_windows_line {
print shift, “\015\012”;
}

def print_windows(line)
print “#{line}\r\n”
end

sub call_a_routine {
my ($routine, $argument) = @_;
$routine->($argument);
}

def call_a_routine(args)
yield args
end

&call_a_routine(&print_unix_line, ‘Hello, unix World!’);
&call_a_routine(&print_windows_line, ‘Hello, Windows World!’);

call_a_routine(‘hello, unix world!’) { |line| print_unix line }
call_a_routine(‘hello, windows world’) { |line| print_windows line }

The “&” prefixed parts are references to subroutines. I have
tried to
recreate this logic in Ruby using Proc blocks, but I can’t get it
to work
properly. Any suggestions?

You can turn a Method into a block argument with &:

call_a_routine ‘text’, &method(:print_unix)
call_a_routine ‘text’, &method(:print_windows)

but don’t do that, its ugly. Use blocks.


Eric H. - removed_email_address@domain.invalid - http://segment7.net
This implementation is HODEL-HASH-9600 compliant

http://trackmap.robotcoop.com


#4

On 1/26/06, Joel VanderWerf removed_email_address@domain.invalid wrote:


vjoel : Joel VanderWerf : path berkeley edu : 510 665 3407

Thanks for the reply! One of the things I had tried was using the
colon character like that, but I didn’t know about also passing the
resulting symbol to “method” as an argument like that. And of course I
also wasn’t going down the lamdba path which I’ll have to do more
experimenting with.

Much appreciated.


#5

wegzumir wrote:

print shift, "\n"

&call_a_routine(&print_unix_line, ‘Hello, unix World!’);
&call_a_routine(&print_windows_line, ‘Hello, Windows World!’);

The “&” prefixed parts are references to subroutines. I have tried to
recreate this logic in Ruby using Proc blocks, but I can’t get it to work
properly. Any suggestions?

first, using a proc

print_unix_line = lambda { |arg|
print arg, “\n”
}

second, using a method

def print_windows_line_method arg
print arg, “\015\012”
end

print_windows_line = method :print_windows_line_method

def call_a_routine routine, arg
routine.call(arg) # or routine[arg]
end

call_a_routine print_unix_line, ‘Hello, unix World!’
call_a_routine print_windows_line, ‘Hello, Windows World!’


#6

On 1/26/06, Eric H. removed_email_address@domain.invalid wrote:

functions and another subroutine that is capable of calling any
end
my ($routine, $argument) = @_;
call_a_routine(‘hello, unix world!’) { |line| print_unix line }
call_a_routine ‘text’, &method(:print_unix)

Cool, so there is a “&” prefix that’s available for use like that. But
I agree with you on it not being as readable in the end. I will have
to work on my block fu a bit.

Many thanks for replying!


#7

On 1/26/06, Austin Z. removed_email_address@domain.invalid wrote:

$routine->($argument);

print_wind_line = lambda { |arg| print arg + “\015\012” }

def call_a_routine(routine, argument)
puts “Hello Ruby, World”

What exactly are you really trying to do?

-austin

Austin Z. * removed_email_address@domain.invalid
* Alternate: removed_email_address@domain.invalid

Yes, my apologies for the example! I was actually trying to strip down
the problem to its barest essentials by making up a hypothetical
scenario.

The whole reason for this (the non hypothetical reason) is because of
the excellent computer science concepts expressed in the book
“Higher-Order Perl”. I’ve used some of those concepts in my Perl code
in the past and I wanted to be able to express the same ideas in Ruby
(and of course be completely open to learning the more Ruby way of
doing the same things instead). In particular, one of the examples at
the beginning of the book is a recursive directory traverser that
accepts references to subroutines for arguments that are mapped as
handlers for what to do when a directory is first opened, when each
file is processed, and once the directory has been finished with.

Many thanks for the two solutions!