Re: use Very::Long::Module::Name as Foo;

[broquaint]

The problem with a source filter approach is that it can very easily run over program data or conflict with existing filters. Personally, I would've thought a straight-forward import approach would've been easiest e.g

package allow_as;

use Carp 'croak';

sub import {
  my($pkg, %args) = @_;
  
  return
    unless exists $args{as} and length $args{as};
    
  croak "Symbol table '$args{as}' already exists"
    if defined *{"$args{as}\::"};
    
  *{"$args{as}\::"} = *{"$pkg\::"};
} 
  
1;

=pod

=head1 USAGE

  package Your::Very::Long::Name::Here;

  use base 'allow_as';

  sub import {
    ## perhaps you want your own import code?
    $_[0]->SUPER::import(@_[1 .. $#_]);
  }

  ## later

  use Your::Very::Long::Name::Here (
    as    => 'yvlnh',
    other => [qw/user parameters perhaps?/],
  );

=cut

This doesn't work as globally as your filtering mechanism, but it also follows in the footsteps of Exporter of allowing the user to simply inherit the module to enable aliasing (which may not always be desirable, like the ability to export random methods). Also, the reason I stuck with the aliasing route is that it is much cleaner than simply using @ISA. It means that objects are blessed into the original package and not the inherited alias, which will keep any introspection consistent, saves avoids dispatching every method call, and it really is an alias as opposed to a quick work-around.

[demerphq]

Method calls are cached so it makes no difference what package they are called against. And the constant-or-variable-with-package-name-in-it approach has the same properties as your code FWICT.

K.I.S.S.

:-)

[broquaint]

Method calls are cached so it makes no difference what package they are called against.

Ah yes, I'm forever forgetting that!

And the constant-or-variable-with-package-name-in-it approach has the same properties as your code FWICT.

But it's not an alias, it's just a shorter way of referring to a package name (although this does equate to the same thing when calling class methods). It means the difference between referring symbolically to the original package, and referring to the package directly via the alias e.g

## accessing a package variable

my $path = ${"$var\::Config"}->{'data_path'};

## vs.

my $path = $alias::Config->{'data_path'};

Ok, so it might be a somewhat contrived, but I think it nicely illustrates that the two approaches are not the same.