You just gave off a few whiffs of bad practice and I'd like to clarify just what you mean. There are some wrong answers here and I'm hoping you'll either confirm or deny that you're being sane.

Exporting new() so it can be used as a function and not just as a method.

use l2kashe 'new';
my $o = new;
$o->foo( ... );
# Vs
use l2kashe;
my $o = l2kashe->new;
$o->foo( ... );
[download]

This is bad practice for a number of reasons. I'll cover whatever comes to mind just now. Keep in mind that I'm internally recoiling from the really hideous things you've brought to mind here.

'new' is the common name for a constructor method. If the importing code already had a 'new' method or function then you've just overwritten the module's own new() method. 'use warnings "redefine"' will catch this and throw a warning but it won't produce a fatal error. In fact, because use() happens at compile time, which version of new() remains in your user's code is up to the order in which they were mentioned.

use l2kashe; # The importing new() dies
sub new { ... } # This one stays
# Vs
sub new { ... } # The original new() dies
use l2kashe; # This one overwrites
[download]

The expectation is that the constructor is tied to the class it originates in. Your constructor will have to hard code the originating class so that it can still reference l2kashe instead of wherever it was copied to. We all know hard coding data like this is poor form.

sub new { bless {}, shift }
# Vs
sub new { bless {}, __PACKAGE__}
# or maybe even:
sub new { bless {}, 'l2kashe' }
[download]

Your constructor has to function as a method and a function now. This is highly irregular and is one of the funkiest things that CGI.pm does. You have to include code in new() that decides whether $_[0] is the class name it should use (if it was called as a method) or whether it is just the first parameter (if it was called as a function). Properly done, the first argument is always the class name. That detail is handled by calling the constructor as a method - this is why you often see code that looks like this

In your case you have to distinguish between strings that are class names and strings that are parameters. Its possible but you've now eliminated the class name as an available value to the first parameter.

sub new {
    my $class_or_parameter = shift;
    if ( $class ne __PACKAGE__ ) {
        unshift @_, $class_or_package;
    }
    bless { @_ }, __PACKAGE__;
}
[download]

You also intimated that maybe your other functions/methods also are expected to be called as both functions or methods. In this case you have to be even tricker and introduce significant evil to all of your code.

sub something {
    my $self_or_parameter = shift;
    if ( ref $self_or_parameter eq __PACKAGE__ ) {
        unshift @_, $self_or_parameter;
    }
     ...
}
[download]

For the moment anyway, I can't see anything but really evil things down this path. Object oriented perl code just does not use Exporter. There is 100% no need for it. the expectation is that your constructor is a method call using the class on the left side of the arrow: SomeClass->new. Some people argue you should be able to do $o->new, I'll not address that but certainly out is SomeClass::new. Additionally, all of your methods that are not constructors are always called as methods and always with the left side being the object in question. So $o->method, never SomeClass->method or SomeClass::method.