Learning Perl Objects, References amp;amp; Modules [Electronic resources] نسخه متنی

10.3 Indirect Object Notation

The arrow syntax used to invoke a method
is sometimes called the direct object syntax
because there's also the indirect
object syntax, also known as the "only
works sometimes" syntax, for reasons explained in a
moment. When you write:

Class->class_method(@args);
$instance->instance_method(@other);

you can generally replace it with:

classmethod Class @args;
instancemethod $instance @other;

A typical use of this is with the
new method, replacing:

my $obj = Some::Class->new(@constructor_params);

with:

my $obj = new Some::Class @constructor_params;

making the C++ people feel right at home. Of course, in Perl,
there's nothing special about the name
new, but at least the syntax is hauntingly
familiar.

Why the previous "generally"
caveat? Well, if the instance is something more complicated than a
simple scalar variable:

$somehash->{$somekey}->[42]->instance_method(@parms);

then you can't just swap it around like:

instance_method $somehash->{$somekey}->[42] @parms;

because the only things acceptable to indirect object syntax are a
bareword (e.g., a class name), a simple scalar variable, or braces
denoting a block returning either a blessed reference or a
classname.[6]

[6] Astute readers will note that these are
the same rules as for an indirect filehandle syntax, from which
indirect object syntax directly mirrors, as well as the rules for
specifying a reference to be dereferenced.

This
means you have to write it like so:

instance_method { $somehash->{$somekey}->[42] } @parms;

And that goes from simple to uglier in one step.
There's another downside: ambiguous parsing. When we
developed the classroom materials concerning indirect object
references, we wrote:

my $cow = Cow->named("Bessie");
print name $cow, " eats.\n";

because we were thinking about the indirect object equivalents for:

my $cow = Cow->named("Bessie");
print $cow->name, " eats.\n";

However, the latter works; the former
doesn't. We were getting no output. Finally, we
enabled warnings (via -w on the command
line)[7] and got this interesting series
of messages:

[7] Using -w should be the first
step when Perl does something you don't understand.
Or maybe it should be the zeroth because you should normally have
-w in effect whenever you're
developing code.

Unquoted string "name" may clash with future reserved word at ./foo line 92.
Name "main::name" used only once: possible typo at ./foo line 92.
print(  ) on unopened filehandle name at ./foo line 92.

Ahh, so that line was being parsed as:

print name ($cow, " eats.\n");

In other words, print the list of items to the filehandle named
name. That's clearly not what we
wanted, so we had to add additional syntax to disambiguate the call.

This
leads us to our next strong suggestion:

Use direct object syntax at all times, except perhaps for the constructor call.

That exception acknowledges that most people write
new Class
... rather than
Class->new(...) and that most of us are fine
with that. However, there are circumstances in which even that can
lead to ambiguity (e.g., when a subroutine named
new has been seen, and the class name itself has
not been seen as a package). When in doubt, ignore indirect object
syntax. Your maintenance programmer will thank you.