Forum: Ruby Pass References To Methods As Arguments?

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.
67b87c971c920eb10f481e980f39ff70?d=identicon&s=25 wegzumir (Guest)
on 2006-01-27 02:43
(Received via mailing list)
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?
31ab75f7ddda241830659630746cdd3a?d=identicon&s=25 Austin Ziegler (Guest)
on 2006-01-27 04:16
(Received via mailing list)
On 26/01/06, wegzumir <wegzumir@gmail.com> 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:

1.

  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.")

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 ||= 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
58479f76374a3ba3c69b9804163f39f4?d=identicon&s=25 Eric Hodel (Guest)
on 2006-01-27 04:16
(Received via mailing list)
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 Hodel - drbrain@segment7.net - http://segment7.net
This implementation is HODEL-HASH-9600 compliant

http://trackmap.robotcoop.com
47b1910084592eb77a032bc7d8d1a84e?d=identicon&s=25 Joel VanderWerf (Guest)
on 2006-01-27 04:16
(Received via mailing list)
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!'
67b87c971c920eb10f481e980f39ff70?d=identicon&s=25 wegzumir (Guest)
on 2006-01-27 05:28
(Received via mailing list)
On 1/26/06, Joel VanderWerf <vjoel@path.berkeley.edu> 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.
67b87c971c920eb10f481e980f39ff70?d=identicon&s=25 wegzumir (Guest)
on 2006-01-27 05:31
(Received via mailing list)
On 1/26/06, Eric Hodel <drbrain@segment7.net> 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!
67b87c971c920eb10f481e980f39ff70?d=identicon&s=25 wegzumir (Guest)
on 2006-01-27 05:40
(Received via mailing list)
On 1/26/06, Austin Ziegler <halostatue@gmail.com> 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 Ziegler * halostatue@gmail.com
>                * Alternate: austin@halostatue.ca
>
>

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!
This topic is locked and can not be replied to.