Pass References To Methods As Arguments?

[wegzumir]

------=_Part_31975_15876149.1138326083042
Content-Type: text/plain; charset=ISO-8859-1
Content-Transfer-Encoding: quoted-printable
Content-Disposition: inline

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) =3D @_;
$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?

------=_Part_31975_15876149.1138326083042--

 

[konsu]

Hello,

would Object#method work?

konstantin

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?

 

[Austin Ziegler]

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.

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) =3D @_;
$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:

1.

print_unix_line =3D lambda { |arg| print arg + "\n" }
print_wind_line =3D 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.")

2.

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 ||=3D Routines.new
@@routine.__send__(routine, argument)
end

call_a_routineprint_unix_line, "Hello, unix.")
call_a_routineprint_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

 

[Joel VanderWerf]

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?

# 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 rint_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!'

 

[wegzumir]

# first, using a proc
print_unix_line =3D lambda { |arg|
print arg, "\n"
}

# second, using a method
def print_windows_line_method arg
print arg, "\015\012"
end

print_windows_line =3D method rint_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!'

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.

 

[wegzumir]

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


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


def call_a_routine(args)
yield args
end


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


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

call_a_routine 'text', &methodprint_unix)
call_a_routine 'text', &methodprint_windows)

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

--
Eric Hodel - (e-mail address removed) - http://segment7.net
This implementation is HODEL-HASH-9600 compliant

http://trackmap.robotcoop.com

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!

 

[wegzumir]

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.

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) =3D @_;
$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:

1.

print_unix_line =3D lambda { |arg| print arg + "\n" }
print_wind_line =3D 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.")

2.

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 ||=3D Routines.new
@@routine.__send__(routine, argument)
end

call_a_routineprint_unix_line, "Hello, unix.")
call_a_routineprint_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

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!