Why do some users quote classnames in Perl?

Question

Looking at Type::Tiny, I see that the class name in the call to Type::Tiny->new is quoted in the official docs,

my $NUM = "Type::Tiny"->new(
   name       => "Number",
   constraint => sub { looks_like_number($_) },
   message    => sub { "$_ ain't a number" },
);

Why is this? Is this mere style? Is there any performance ramifications for this practice?

Answer 1

Take a simpler example

package Foo { sub new { die 7  } };
package Bar { sub new { die 42 } };
sub Foo { "Bar" }
Foo->new();

In the above example, the constant Foo resolves to "Bar", so so this calls "Bar"->new not "Foo"->new. How do you stop the subroutine from resolving? You can quote it.

"Foo"->new();

As for the performance implication, things are not made worse by using a string rather than a bareword. I've confirmed the optree generated by O=Deparse is the same. So as a general rule, it seems it's better to quote the Classnames if you value correctness.

This is mentioned in Programming Perl, (sadly in the context of indirect method invocation)

... so we'll tell you that you can almost always get away with a bare class name, provided two things are true. First, there is no subroutine of the same name as the class. (If you follow the convention that subroutine names like new start lowercase and class names like ElvenRing start uppercase, this is never a problem). Second, the class been loaded with one of

use ElvenRing;
require ElvenRing;

Either of these declarations ensures that Perl knows ElvenRing is a module name, which forces any bare name like new before the class name ElvenRing to be interpreted as a method call, even if you happen to have declare a new subroutine of your own in the current package.

And, that makes sense: the confusion here can only happen if your subroutines (typically lowercase) have the same name as a class (typically uppercase). This can only happen if you violate that naming convention above.

tldr; it is probably a good idea to quote your classnames, if you know them and you value correctness over clutter.

Side note: alternatively you can stop resolution of a bareword to a function by affixing a :: to the end of it, for example in the above Foo::->new.

---

Thanks to Ginnz on reddit for pointing this out to me, and to Toby Inkster for the comment (though it didn't make sense to me on first read).

Answer 2

Explicitly quoting the class name rather than using a bareword (which is treated as a string) is one of three ways to avoid syntactic ambiguity. The Invoking Class Methods section of the perlobj documentation explains.

Because Perl allows you to use barewords for package names and subroutine names, it sometimes interprets a bareword’s meaning incorrectly. For example, the construct Class->new() can be interpreted as either 'Class'->new() or Class()->new() .In English, that second interpretation reads as “call a subroutine named Class(), then call new() as a method on the return value of Class().” If there is a subroutine named Class() in the current namespace, Perl will always interpret Class->new() as the second alternative: a call to new() on the object returned by a call to Class().

See this odd case in action with the demo below.

#! /usr/bin/env perl

use strict;
use warnings;

sub Type::Tiny { print "Returning Bogus\n" ; return "Bogus" }

sub Type::Tiny::new { print "Type::Tiny::new\n" }

sub Bogus::new { print "Bogus::new\n" }

my $class = "Type::Tiny";

Type::Tiny->new;
Type::Tiny::->new;
"Type::Tiny"->new;
$class->new;

Its output is

Returning Bogus
Bogus::new
Type::Tiny::new
Type::Tiny::new
Type::Tiny::new

The rest of the aforementioned documentation section shows how to protect against surprising behavior or inadvertent errors.

You can force Perl to use the first interpretation (i.e., as a method call on the class named "Class") in two ways. First, you can append a :: to the class name:

Class::->new()

Perl will always interpret this as a method call.

Alternatively, you can quote the class name:

'Class'->new()

Of course, if the class name is in a scalar Perl will do the right thing as well:

my $class = 'Class';
$class->new();

Applying to your question, all of the calls below are equivalent.

Type::Tiny::->new( … );

"Type::Tiny"->new( … );

my $class = "Type::Tiny";
$class->new( … );

Appending :: to the end has the advantage of producing a helpful warning. Say you accidentally typed

Type::Tinny::->new;

That produces

Bareword "Type::Tinny::" refers to nonexistent package at ./try line 15.
Can't locate object method "new" via package "Type::Tinny" (perhaps you forgot to load "Type::Tinny"?) at ./try line 15.