Re: what is sub {1;}

[moritz]

sub {1;} is an anonymous subroutine that always returns 1.

my $x = sub {1; };
print $x->();

[mandarin]

and what would be the use of such construct?

[moritz]

As a default value.

Suppose you write a sub (or module) that processes some values, and you want to offer the caller the possibility to filter some of them. Now you've got two options:

sub process {
   my ($data, $filter) = @_;
   # lengthy calculations with $data here ...
   # in that length calculation you have to decide
   # if you continue with your calculation:

   for (@$data){
   if ($filter) {
       if ($filter->($_)){
          push @$data, other_lengthy_calculation($_);

       }
   } else {
       push @$data, other_lengthy_calculation($_);
   }
}
# second option:
sub process {
   my ($data, $filter) = @_;

   # provide a default value for $filter
   $filter = sub {1;} unless $filter;

   # lengthy calculations with $data here ...
   # in that length calculation you have to decide
   # if you continue with your calculation:

   for (@$data){
   if ($filter->($_)) {
       push @$data, other_lengthy_calculation($_);
   }
}

You can see that the construct with the default value is much shorter (3 instead of ~8 lines), and it's much cleaner.

If you're interested in more details on callbacks, anonymous subs and many more advanced techniques, I strongly recommend the book "Higher Order Perl" by Mark Jason Dominus.

[ruzam]

# third option:
sub process {
 my ($data, $filter) = @_;

 # lengthy calculations with $data here ... 
 # in that length calculation you have to decide
 # if you continue with your calculation:

 if ($filter) {
   for (@$data){
     if ($filter->($_)) {
       push @$data, other_lengthy_calculation($_);
     }
   }
 }
 else {
   for (@$data){
     push @$data, other_lengthy_calculation($_);
   }
 }

Sure, it involves more lines (12 now instead of ~8 lines), but why you would deliberately want to throw a costly sub call in a loop? If @$data is huge and $filter is usually empty, using '$filter = sub {1;}' could quickly become a bottleneck.

I agree with the OP, use of a sub {1;} to avoid 'undefined' doesn't make much sense (to me anyway), unless the application interface guarantees that parameter to be a sub reference all the time. But that's not clear from the code snippet.

[ikegami]

It allows

my $rv = $args{'Post'} ? $args{'Post'}->() : 1;

to be simplified to

my $rv = $args{'Post'}->();

Or if the return value isn't checked, it allows

$args{'Post'} and $args{'Post'}->();

to be simplified to

$args{'Post'}->();

(sub{} would have been sufficient in the latter case.)

[DrHyde]

It's impossible to say without seeing the rest of the code. I expect that in context it's a sensible default if the user doesn't specify a function himself.