Re^3: why avoid & on function call

[Bod]

From a style point of view (he said, donning his asbestos firesuit), I like having the 'main' part of the routine first, so that at a quick glance of the file, I can see what's going on. If I want further detail, I can scroll down to look at the routines I'm interested in.

We style things the same :)
It is very rare that I arrange code differently to this.

Usually I add an explicit exit statement to the end of the 'main' part of the code before the subroutines so it is obvious where the 'main' block ends.

[talexb]

Usually I add an explicit exit statement to the end of the 'main' part of the code ..

I don't .. because I use braces for my 'mainline' code. Here's a recent script I wrote based on something I saw on Twitter:

#!/usr/bin/perl

use strict;
use warnings;

#  Base 24 question from https://twitter.com/pwnallthethings/status/13
+43590455511023621

my @digits = qw/B C D F G H J K M P Q R T V W X Y 2 3 4 6 7 8 9/;
my %digit_value;

my $string = 'FCKGW-RHQQ2-YXRKT-8TG6W-2B7Q8';

#  Convert a base 24 number to decimal. This is a group of five
#  numbers, like a Windows key.

{
    my $v = 0;
    foreach my $d ( @digits ) { 

        $digit_value{ $d } = $v++;
    }   

    my @units = split ( /-/, $string );
    foreach my $u ( @units ) { 

        my $value = decode ( $u );
        print "$u -> $value\n";
    }   
}

sub decode
{
    my ( $str ) = @_; 

    my $val = 0;
    my @chars = split ( //, $str );

    foreach my $c ( @chars ) { 

        $val *= 24; 
        $val += $digit_value{ $c };
    }   

    return $val;
}

There's no exit required because the closing brace indicates "That's the end!" to Perl. I have seen code where the mainline is right up against the left margin -- I never code like that, because it obscures what's going on -- it's the same level as the use statements, so I don't know where the declarations end and the executable code starts.

And I don't put an exit anywhere, because that would indicate I was bailing out early, instead of allowing the syntax to naturally indicate where the end of the procedure is. To be clear, I'm *not* saying your way is wrong -- it's just not what I prefer. I like my way because it's clear and legible. For me, white space is my friend.

[LanX]

> Usually I add an explicit exit statement to the end of the main part of the code before the subroutines so it is obvious where the main block ends.

exit doesn't end scope.

If you have variables declared in your main part, they could accidentally leak as closures into the subs.

Using sub main { BLOCK } is one way to limit the scope.

I personally rather use a naked { BLOCK }

Like this the distinction to intentionally file-scoped variables outside this main BLOCK becomes obvious.

[stevieb]

"Usually I add an explicit exit statement to the end of the 'main' part of the code before the subroutines so it is obvious where the 'main' block ends."

Meh, use an editor that folds sub code, and it's impossible not to easily see where main ends and subs begin.

I'm with talexb on the exit... to me, exit indicates an early emergency-type return. Although I don't put my main code within a block, I don't use exit either. I do though always put my main code before all of the sub definitions, unless there's a very good reason not to.

An exception to the main section blocks is in my test files. Each of my test files typically tests a single subroutine, and I like a pristine environment for every set of tests (eg. bad parameters, first parameter valid/invalid, second parameter valid/invalid etc), again with folding ability. eg:

# bad params
{code-block}

# validate date param format
{code-block}

# validate date param range
{code-block}

...

I thought I wrote up an article once here on Perlmonks regarding folding Perl code, and turns out I was right. I also have a screenshot.