In perl or almost any other functional language (I guess) you can combine functions together and the innards of one thing aren't going to affect the flow control of the other. Here's a simple bit of perl:
method trap (CodeRef $block) {
$block->() }
uffda(); # Called in Perl, not called in Ruby
}
method moo (... ) {
trap( sub {
# Early return because...
return... if ...;
...
} );
}
Writing the equivalent flow control in Ruby and I found out today that the return() calls go all the way through and past the wrapping "trap" function.
WTF? I don't think I understand how Ruby programmers put up with this. Maybe 1.9 is better about this.
Block/Proc (Score:1)
I don't have time to experiment myself, but is this the difference between a Block and a Proc again?
Re: (Score:1)
Re: (Score:1)
Oops, yes. So I just learned that blocks aren't functions even though they syntactically look like them. Apparently this would have worked just fine if I'd passed a proc{} in and use .call on it instead.
I'm not sure why Rubyists accept blocks the way they are.
Heck, why do perlers except that map and grep's little lambdas don't treat return() properly?
The Reason Why (I Think) (Score:1)
use feature ':5.10';
sub foo {
say 'beginning of foo';
bar();
say 'ending of foo';
}
sub bar {
say 'beginning of bar';
my @foo = grep { return } (1,2,3,4); # I'd say this should mean none
say 'ending of bar';
}
foo();
Note that the grep kills bar.
--fREW
http://blog.afoolishmanifesto.com