Re^3: RFC: Simulating Ruby's "yield" and "blocks" in Perl

[Jenda]

If you call the thing "$c_ref" then sure, it did not give you any advantage over the ill-named keyword. If on the other hand you use a descriptive name, the code gets must more readable. The Ruby syntax gives you no hint about what is the block supposed to do, what is it supposed to accept or return, it doesn't tell you anything! On one side you hear rubystas babble about how bad the Perl default variable $_ is and then they use something like this for something conceptually much more complicated and give you no chance to name the thing should you feel the need to. Perl let's you write foreach (@array) as well as foreach my $meaningful_name (@array), Ruby doesn't give you a chance to name the coderef/closure. It doesn't even admit there's one. To make things even funnier, it doesn't even tell you the method accepts a coderef (or block if you will) and the only way to find out is to read the method's body. The (&) at least tells you the subroutine expects a block, Ruby doesn't tell you anything.

If you do not want to name the coderef, go ahead an use $_[-1]->(1), it's just as cryptic as yield.

BTW, please translate these two to Ruby:

sub search {
  my $wanted = shift;
  foreach my $path (@_) {
   print "Searching in '$path'\n";
   find($wanted, $path);
  }
}
# I don't care about the File::Find ... how do you pass the block to a
+nother subroutine/method?

sub walk_tree {
  my ($self, $branch_handler, $leaf_handler) = @_;
  if ($self->isLeaf()) {
   $leaf_handler->($self->{data});
  } else {
   $branch_handler->{$self->{data}};
   foreach my $child ($self->children()) {
    $child->walk_tree($branch_handler, $leaf_handler);
   }
  }
}

Now how big is the leap from a single block to multiple in Perl and in Ruby? How hard is it to do something nontrivial in Perl and in Ruby? Ruby's syntax makes simple things short and awkward and hard things next to impossible.

[LanX]

Upvoted for less emotions and more arguments! =)

There is a misunderstanding, I'm neither a Ruby fanboy nor an expert.

I already explained my motivation in detail, namely to show Perls strength.

> BTW, please translate these two to Ruby:

sub search {
  my $wanted = shift;
  foreach my $path (@_) {
   print "Searching in '$path'\n";
   find($wanted, $path);
  }
}

ehm, maybe something like?

paths.each do
  |path|
  puts "Searching in %{path}"
  find(wanted, path)
end

> Now how big is the leap from a single block to multiple in Perl and in Ruby? How hard is it to do something nontrivial in Perl and in Ruby? Ruby's syntax makes simple things short and awkward and hard things next to impossible.

No idea. Again, my intention was to show that Perl is so flexible that it can even emulate Ruby. Ruby claims to be a DSL language, while Perl can "dsl" Ruby =).

Why shouldn't we steal the sexy parts and add it to our portfolio?

update

> how do you pass the block to another subroutine/method?

according to Passing Blocks in Ruby Without &block there are basically two possibilities:

Either explicitly adding a &block in the signature or using Proc.new.

update

thats your question?

 
irb(main):006:0> wanted = "c"
=> "c"

irb(main):021:0> def search (paths, &block)
irb(main):022:1>    paths.each &block
irb(main):023:1> end 

irb(main):028:0> search ["a", "b", "c"] do
irb(main):029:1*   |path|
irb(main):030:1*   puts "Searching in #{path}"
irb(main):031:1>   puts wanted == path
irb(main):032:1> end
Searching in a
false
Searching in b
false
Searching in c
true