What is the difference between new Some::Class and Some::Class->new() in Perl?

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.

Answer 2

See Indirect Object Syntax in the perlobj documentation for an explanation of its pitfalls. freido's answer covers one of them (although I tend to avoid that with explicit parens around my function calls).

Larry once joked that it was there to make the C++ feel happy about new, and although people will tell you not to ever use it, you're probably doing it all the time. Consider this:

print FH "Some message"; 

Have you ever wondered my there was no comma after the filehandle? And there's no comma after the class name in the indirect object notation? That's what's going on here. You could rewrite that as a method call on print:

FH->print( "Some message" ); 

You may have experienced some weirdness in print if you do it wrong. Putting a comma after the explicit file handle turns it into an argument:

print FH, "some message";     # GLOB(0xDEADBEEF)some message 

Sadly, we have this goofiness in Perl. Not everything that got into the syntax was the best idea, but that's what happens when you pull from so many sources for inspiration. Some of the ideas have to be the bad ones.