package Foo;

my $_private = sub { ... };
my _private = sub { ... };

sub foo {
    my $self = shift;
    
    # we can specify the full package name
    $self->Foo::_private();
    
    # we can call as a subroutine
    _private($self);
    
    # we can use lexically scoped subs
    $self->$_private();
};
[download]

• LongPackageNamesCanGetSomewhatTediousToType
• Using subroutine calling style makes it harder to switch to/from private/public methods during development
• With PackageNames and subroutine calls the method is still visible in subclasses
• When you use lexically scoped subroutines you have to be share your method name space with your other lexical scalars

With the package name and subroutine calling methods we can prevent the method from being inherited by subclasses by putting it in a seperate package (see (tye)Re: Private Class Methods for an example). So we can do things like:

package Foo;

sub Foo::private::method { ... };

sub foo {
    my $self = shift;
    $self->Foo::private::method { ... };
};
[download]

Which is nice, but we still have to repeat the Foo::private package every time we call the method - which for VeryLongPackageNames could be tedious.

A convenient shortcut to the private method space would be nice. Maybe something like:

sub Foo::MY::method { ... };

sub foo {
    my $self = shift;
    $self->MY::method();
};
[download]

This fits in quite nicely with SUPER:: and NEXT::.

This is actually pretty trivial to implement - just stick an AUTOLOAD in the MY package:

package MY;

sub AUTOLOAD {
    my $self = shift;
    our $AUTOLOAD;
    my $method = caller() . "::$AUTOLOAD";
    $self->$method(@_);
};
[download]

and Bob's the parental sibling of your choice.

Unfortunately this adds an extra method call worth of overhead to every private method. Probably a bad move - Perl's method invocation is slow enough as it is.

It would also be nice to be able to do:

sub MY::method { ... };
[download]

rather than

sub MyLongPackageName::MY::method { ... };
[download]

Having to repeat MyLongPackageName for every private method definition is a pain.

Looks like a job for (and I don't say this very often because they're evil :-) a source filter.

package MY;
use strict;
use warnings;

my $Imported_from;
sub import { $Imported_from = caller };

use Filter::Simple;
FILTER_ONLY code => sub { s/(\w+::)*MY::/${Imported_from}::MY::/gs };

1;
[download]

Which will allow us to write code like this:

package Foo;
use MY;

sub new { bless {}, shift };

sub hello {
    my $self = shift;
    $self->MY::greet_world("hi");
};

sub MY::greet_world {
    my ($self, $greeting) = @_;
    print "$greeting world\n";
};


package Bar;
use base qw(Foo);
use MY;

sub new {
    my $class = shift;
    $class->MY::greet_world();
    return $class->SUPER::new(@_);
};

sub MY::greet_world {
    print "A new Bar has entered the world\n";
};
[download]

Without the two private greet_world() methods of Foo and Bar interfering, and without any run-time overhead.

Neat.

Worth throwing at CPAN?