Using an unknown method in Perl

Question

I have trouble understanding, why Perl executes the code in curly braces in programs like this one:

unknown_method {
    # some code
};

My program:

file Transaction.pm:

package Transaction;
use strict;
use warnings;
use feature qw/ say /;

sub transaction(&) {
    say 'BEGIN TRANSACTION';
    eval {
        shift->()
    };
    if ( $@ ) {
        say 'ROLLBACK TRANSACTION';
        die($@);  # reraise error
    } else {
        say 'COMMIT TRANSACTION';
    }
}
1;

file run_properly.pl:

use feature qw/ say /;
use Transaction;
eval {
    Transaction::transaction {
        say "insert some data to DB";
        die("KnownException")
    }
};
warn $@;

file run_wrong.pl:

use feature qw/ say /;
# I forgot to import Transaction
eval {
    Transaction::transaction {
        say "insert some data to DB";
        die("KnownException")
    }
};
warn $@;

Execution:

$ perl run_properly.pl 
BEGIN TRANSACTION
insert some data to DB
ROLLBACK TRANSACTION
KnownException at run_properly.pl line 6.

and

$ perl run_wrong.pl 
insert some data to DB
KnownException at run_wrong.pl line 6.

Why Perl allows such a thing?

Answer 1

Perl is syntactically flexible, and often has more than one syntax do do things. For example, calling methods. This is regular and recommended syntax:

  Foo  ->  new       (1, 2, 3);
# ^-object ^- method ^- arguments

This is the indirect syntax:

  new       Foo       1, 2, 3;
# ^- method ^- object ^- arguments, parens are optional

This is all fine and well, but what happens when we want to use the result of a complex computation as object with indirect object notation?

# set up some constructors for demonstration purposes
*Foo::new = *Bar::new = sub {say "@_"};

# This obviously fails
# new (rand > .5 ? "Foo" : "Bar") 1, 2, 3;

The solution is a dative block:

new {rand > .5 ? "Foo" : "Bar"} 1, 2, 3;

You probably already know dative blocks from filehandles: print {$handles[-1]} $_.

The dative block is executed before method resolution, as method resolution generally (but not in your case) depends on the type of the object. However, no methods are resolved if the block dies.

---

Indirect notation is still quite popular for constructors, as it makes Perl look like C++. However, Perl (unlike C++) has no new operator: it's just a regular method. This flexibility may have been a bad idea, so you can “fix” it by using no indirect if you feel strongly about this.