Now if you want parametrized uses, consider the following (untested):

package load;
use Carp;
use strict;

sub as {
  my $pkg = shift;

  # Set the alias.
  $_[0] = $pkg;

  # load the module
  eval "require $pkg";
  die $@ if $@;

  # import it?
  shift;
  if (@_) {
    unshift @_, $pkg;
    my $import = $pkg->can("import")
      or croak("No import available to use");
    goto &$import;
  }
}

1;
[download]

use load;
Very::Long::Module->load::as my $short => qw(foo bar baz);
[download]

In any case the difference in ease of usage between these solutions and a source filter is pretty minor. The difference in potential problems is pretty large. (Note that I am steering towards solutions where you can create any aliases for yourself without trampling on any potential global namespace. That is both deliberate and, I feel, important.)

Funny you put your example in the load namespace ;-). Or was that intentional?

I guess we agree to disagree. I find the syntax of

Very::Long::Module->load::as my $short => qw(foo bar baz);
[download]

very confusing. And a strange, roundabout way of setting $short.

...without trampling on any potential global namespace...

I think you touch on a very important flaw of my "as.pm" and of Package::Alias' approach as well. Consider a program which has:

use Foo;
use Bar;
[download]

Now, Foo.pm has the following shortening (using my syntax for ease of reading):

package Foo;
use Very::Long::Module::Name as Shorty;
[download]

and Bar.pm has the following shortening:

package Bar;
use Some::Other::Long::Module::Name as Shorty;
[download]

Then you see we have a problem. One of the two modules will be referring to the wrong long module name, depending on whether an existing stash would be overwritten or not. In other words: you can only have one Shorty. That's because the stash aliasing (or the @ISA assignment) is not limited to the package scope from which it is invoked. And I don't see a way to encapsulate it, as all of the object creation is at run-time.

In my view, this pulls the rug from under any shortening approach currently available. As you cannot create code that can be well-behaved in that respect.

Too bad. It was a nice idea while it lasted... ;-)

Liz

Re-using load was not intentional, I was just looking for a name that made that line read relatively nicely, and I was in a hurry because I was late for work.

As for the shortening approach, putting the package name in a variable works reasonably well. Putting the package name in a constant somewhat works. Both will work with the direct syntax, but not the indirect, my differing judgements on them are that people who don't understand the magic are (at a guess) more likely to accept the syntax error from the variable than from the constant. That is:

my $short = 'Very::Long::Module';
use constant Short => 'Very::Long::Module';

# Later the following work:
$short->new(@args);
Short->new(@args);

# The following do not:
new $short(@args);           # I'm guessing unsurprising?
new Short(@args);            # Possibly puzzling?
[download]

It would, I guess, be possible to use source filtering to both set a constant and to rewrite indirect method calls. I wouldn't trust it too much though...

Wouldn't you have to transform Foo::Bar::Baz to Foo/Bar/Baz.pm, to make it work with require?

------
We are the carpenters and bricklayers of the Information Age.

The idea is a little like C++ templates, except not quite so brain-meltingly complicated. -- TheDamian, Exegesis 6

... strings and arrays will suffice. As they are easily available as native data types in any sane language, ... - blokhead, speaking on evolutionary algorithms

Please remember that I'm crufty and crochety. All opinions are purely mine and all code is untested, unless otherwise specified.

No, because it is a source filter. It changes source such as:

use Very::Long::Module::Name as Foo;
[download]

to:

BEGIN {*{"Foo::"} = \*{"Very::Long::Module::Name::"}}use Very::Long::M
+odule::Name;
[download]

essentially aliasing the stashes of the Foo namespace with the Very::Long::Module::Name namespace at compile time.

So this is before anything is required under "use"s hood.

Liz

Wouldn't you have to transform Foo::Bar::Baz to Foo/Bar/Baz.pm, to make it work with require?

No. That was the point of the string eval.