in reply to Re^2: Continuations in Perl - Returning to an arbitrary level up the call stack
in thread Continuations in Perl - Returning to an arbitrary level up the call stack

For instance, when design a recursion to search a graph it's sometimes desirable to stop immediately after the goal is reached.

I'm having trouble imagining a routine designed to search a graph, where finding the target is a special case?

No need to backtrack and branch thru the whole labyrinth after the exit is already found!

The emotive language makes it sound like returning from (several nested) subroutines is a difficult thing to do; but that is what subroutines do. Via a return or falling off the end. it is neither hard to program nor costly in executions time.

Indeed, whatever alternative mechanism is used, in whatever language, it will always be more costly than the natural return chain. The stack still has to be unwound

Just as the exception mechanism in C++ (or structured exceptions in MSC), are a magnitude or more expensive because they have to search back up the stack looking for stack frames interpreting them as they go; so the goto that underlies such mechanisms in Perl has to go through an equally convoluted process to find a label at the appropriate scope.

Such costs and overheads -- not to mention the difficulties they create when they fail to work as expected and need to be traced and debugged -- are just about acceptable for the exceptional (rare, non-normal) cases they are designed for; but wrapping them over in a cute sounding abstraction and subverting them for use in the general case -- such as a search routine finding what it is looking for -- seems like abuse of the very worse kind to me.

Whilst I'm sure it is possible to contrive a theoretical use case that might stand up to cursory inspection; but unless I saw a real-world use case that I couldn't find a less obscure alternative, any use of the mechanism would garner a big red flag in any code review I was involved in.

Luckily, neither the OP nor you have to subject your code to my review :)

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'
Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
"Science is about questioning the status quo. Questioning authority".
In the absence of evidence, opinion is indistinguishable from prejudice.
  • Comment on Re^3: Continuations in Perl - Returning to an arbitrary level up the call stack

Replies are listed 'Best First'.
Re^4: Continuations in Perl - Returning to an arbitrary level up the call stack
by LanX (Saint) on May 19, 2013 at 02:34 UTC
    > Luckily, neither the OP nor you have to subject your code to my review :)

    and vice versa!

    Cheers Rolf

    ( addicted to the Perl Programming Language)

[reply]
Re^4: Continuations in Perl - Returning to an arbitrary level up the call stack
by LanX (Saint) on May 20, 2013 at 20:07 UTC
    Your inerrant holiness who represents all of us!

    > Indeed, whatever alternative mechanism is used, in whatever language, it will always be more costly than the natural return chain. The stack still has to be unwound

    > Just as the exception mechanism in C++ (or structured exceptions in MSC), are a magnitude or more expensive because they have to search back up the stack looking for stack frames interpreting them as they go; so the goto that underlies such mechanisms in Perl has to go through an equally convoluted process to find a label at the appropriate scope.

    Some heretics didn't fully trust you and tried to measure a time penalty for die or goto.

    Look what they have done!

    Timing for 1000000 recursions:
    Mode: return takes sec: 5.55880403518677
    Mode: goto takes sec: 4.51015114784241
    Mode: die takes sec: 1.70386385917664

    [download]

    use Time::HiRes qw/time/;

no warnings 'recursion';


our $mode;

sub rec {
  my $i=shift;
  $i--;
  if ($i<0) {
    return  if $mode eq "return";
    goto OUT if $mode eq "goto";
    die "finished" if $mode eq "die";
  }
  rec($i)
}

$|=1;

my $recs=1000000;

print "Timing for $recs recursions:\n" ;

for $mode (qw/return goto die/) {
  print "\tMode: $mode takes sec: ";
  my $start=time;
  eval {
    rec($recs);
  };
 OUT:
  # print $@ if $@;
  print time-$start,"\n";
}

    [download]

    Please prove them wrong!

    May those heathens all burn in hell (...or emacs)!

    Cheers Rolf

    ( addicted to the Perl Programming Language)

[reply]
[d/l]
[select]

      He he. Thanks again. You get funnier and funnier.

      Let's see, what does this measure? Hm. Decrementing a variable a million times and doing nothing with the result.

      Okay then, this does that 30 times faster:

      #! perl -slw
use strict;
use Time::HiRes qw/time/;

my $i = 1e6;
my $start = time;
1 while --$i;
printf "Took %f seconds\n", time - $start;

__END__
C:\test>1034296.pl
Took 0.062912 seconds

      [download]
      With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'
      Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.
      "Science is about questioning the status quo. Questioning authority".
      In the absence of evidence, opinion is indistinguishable from prejudice.
[reply]
[d/l]
        Bielefeld does not exist!
[reply]

In Section Seekers of Perl Wisdom