Re: Re (tilly) 4: Paradigm Shift - when to use goto

[TheDamian]

I concur with everything tilly said above. To summarize, a goto is not considered harmful when you're:

• replacing the current subroutine via a goto &othersub (rare),
• autogenerating code that will never be seen or maintained directly (rarer),
• implementing a flow-of-control that Perl doesn't support natively (rarest).

For me, the key point in tilly's reply is that virtually all other "legitimate" uses of a goto in other languages are made redundant in Perl by the availability of named loops.

Whereas in C/C++ you might reasonably have to write:

    for (i=1; i<10; i++) {
      for (j=1; j<10; j++) {
        for (k=1; k<10; k++) {
          /* Process data[i][j][k] here */
          if (data[i][j][k] < threshold) goto EOLOOPS;
        }
      }
    }
    EOLOOPS:

Perl has a much cleaner way to escape from a deep nesting:

    LOOPS: for $i (1..10) {
             for $j (1..10) {
               for $k (1..10) {
                 # Process $data[$i][$j][$k] here
                 last LOOPS if $data[$i][$j][$k] < $threshold;
               }
             }
           }

Long ago, before I discovered the Way of the Camel, I used to rely on a couple of moderately evil preprocessor commands to give myself named loops in C/C++ too:

    #define named(name) goto name; name##_break: if (0) name:
    #define break(name) goto name##_break;

    /* Which then allows you to write... */

    named (LOOPS) for (i=1; i<10; i++) {
                    for (j=1; j<10; j++) {
                      for (j=1; j<10; j++) {
                        /* Process data[i][j][k] here */
                        if (data[i][j][k] < threshold) break(LOOPS);
                      }
                    }
                  }

Exploring how those #defines work -- and why they don't interfere with the semantics of normal (unnamed) break statements -- is left as an exercise for those of you who still follow the Dark Path. ;-)

[JadeNB]

To shed my vast light on the discussion, 8 years later: Is this

replacing the current subroutine via a goto &othersub (rare),

really true? I thought that goto was the only way to get proper tail-call recursion, which means that those of us with functional backgrounds who aren't so fond of iteration would be using it a lot.

Incidentally, nothingmuch has recently offered Sub::Call::Tail for those who recoil from the syntactic ugliness of the goto-based set-up. Given your contributions in the past, I imagine you have your own way of twisting tail-calling gotos into shape when the occasion warrants. :-)

[runrig]

Tail-call recursion simulation with goto in perl is pretty slow. See Pure Perl tail call optimization. It's supposed to be better optimized (don't know if it is yet) in Perl 6.