Paranoid as I am, I am wondering whether the automatic loading of Foo::* modules isn't opening some serious security holes, because you can never know whether someone hasn't put a "Foo::Takeovereverything" module somewhere in @INC (especially with "." usually being part of @INC). Of course, this could be considered a feature as well.

Personally, I like the following idiom better for object oriented modules, as it makes it easier to use a lot of modules _and_ still keep a better overview:

use Foo qw(Bar Baz);
[download]

which would be equivalent to:

use Foo ();
use Foo::Bar ();
use Foo::Baz ();
[download]

Foo::import would look something like this:

my @module = qw(Bar Baz); # allowable modules
my %module = map {$_ => 1} @module; # easy lookup of modules 

sub import {
    my $class = shift;
    return if $class ne 'Foo'; # allow import to be inherited by submo
+dules

    my @require;  # list of modules to be required
    if (@_) {
        foreach (@_) {
            if ($_ eq ':all') {
                @require = @module;
            } elsif ($module{$_}) {
                push @require,$_;
            } else {
                warn "Don't know how to load Foo::$_\n";
            }
        }
    } else {
        @require = @module;
    }

    foreach (@require) {
        next if eval "require Foo::$_;"; # string eval for easiness
        warn "Foo::$_: $@"; # could be die also if you prefer
    }
} #import
[download]

With apologies to those for whom this would be bleedingly obvious.

Liz