if (eval "use Module::Foo") {
     # I've got foo!
  } else {
     die $@ if $@;
  }
[download]

If evaling a string makes you squirmy, this should work the same:

  if (eval { require Module::Foo }) {
      Module::Foo->import() if Module::Foo->can('import');
      # I've got foo!
  } else {
      die $@ if $@;
  }
[download]

Note that this will not work:

  if (eval { use Module::Foo }) {
      # I've got foo!
  } else {
      die $@ if $@;
  }
[download]

That's because use is a compile-time statement which can't be trapped by an eval. It'll blow up at compile time if Module::Foo can't be loaded.

-sam

What I mean by this is that I have a small module, one for each module my app knows how to use:

package MyApp::URLFetcher::LWP;
use base qw/MyApp::URLFetcher/;

use LWP::Simple;

# define the most convenient interface you can think of
# if you need just the contents of a URL in a string, do that
sub get_url_to_str {
    my $url = shift;
    get($url); # our chosen interface is simple with LWP
}
[download]

package MyApp::URLFetcher::NetFTP;
use base qw/MyApp::URLFetcher/;

use Net::FTP;

sub get_url_to_str {
    my $self = shift;
    my $url = shift;

    # I don't know Net::FTP
    # either way, our interface is a bit harder to pull off 
    # with Net::FTP
    # but this complexity will be in the software anyway
    # it's better to hide it here
    my $f = Net::FTP->new; # ...
    # ...
    $f->get("...");
}
[download]

Then in your app, say you need a URL:

use UNIVERSAL::require;

my $fetcher_class = choose_fetcher_class();

my $fetcher = $fetcher_class->new;

# this is the good part
# this line of code does not care what driver it's using, as
# long as the subclass of MyApp::URLFetcher is implemented correctly
# isn't polymorphism great?
my $content = $fetcher->get($url);

sub choose_fetcher_class {
    foreach my $driver (qw/LWP NetFTP/){
        my $class = "MyApp::URLFetcher::$driver";
        # UNIVERSAL::require let's us avoid an eval
        return $class if $class->require;
    }
    die "couldn't load any driver";
}
[download]

Update: Oops! I forgot the classes in the foreach loop

Also, you might want to look into Module::Pluggable and friends, they might be useful for "finding" drivers, without the code that uses them even caring about their names. I don't think they have an API to skip failed modules, and furthermore to only get the first successful one.

UNIVERSAL::require does not let us avoid an eval, unless you mean avoid doing the eval ourselves. It precisely does eval "CORE::require $module".

Yeah, I know it's guts. But good point =)

What I meant is that you don't have to construct some perl code, eval it, and maybe get it wrong and stuff.

Encapsulation let's me feel free to ignore most of what's underneath, but normally before I get to that stage I take a good look at the insides to make sure I can trust it.

-nuffin
zz zZ Z Z #!perl

my $hasLWP = eval{require LWP;};

if( $hasLWP ){
 print "LWP is installed\n";
}
else{
  print "LWP not installed.\n";
}
[download]

Rather than doing a series of functionality tests, CPAN generally looks at the module's version, in $Module::Name::VERSION. You may find this technique useful.

eval is a perfectly acceptable way to test if a module can be loaded, but you can use the UNIVERSAL can method to test if particular methods exist.