Question

Many years ago I remember a fellow programmer counselling this:

new Some::Class;    # bad! (but why?)  Some::Class->new(); # good! 

Sadly now I cannot remember the/his reason why. 🙁 Both forms will work correctly even if the constructor does not actually exist in the Some::Class module but instead is inherited from a parent somewhere.

Neither of these forms are the same as Some::Class::new(), which will not pass the name of the class as the first parameter to the constructor — so this form is always incorrect.

Even if the two forms are equivalent, I find Some::Class->new() to be much more clear, as it follows the standard convention for calling a method on a module, and in perl, the ‘new’ method is not special – a constructor could be called anything, and new() could do anything (although of course we generally expect it to be a constructor).

Answer 1

Using new Some::Class is called ‘indirect’ method invocation, and it’s bad because it introduces some ambiguity into the syntax.

One reason it can fail is if you have an array or hash of objects. You might expect

dosomethingwith $hashref->{obj} 

to be equal to

$hashref->{obj}->dosomethingwith(); 

but it actually parses as:

$hashref->dosomethingwith->{obj} 

which probably isn’t what you wanted.

Another problem is if there happens to be a function in your package with the same name as a method you’re trying to call. For example, what if some module that you use‘d exported a function called dosomethingwith? In that case, dosomethingwith $object is ambiguous, and can result in puzzling bugs.

Using the -> syntax exclusively eliminates these problems, because the method and what you want the method to operate upon are always clear to the compiler.