package Foo;
use strict;
use warnings;

my $foo = Foo->new;

$foo->rarelyusedfunction;

Foo::CodeLoader->new->list();



sub new
{
        return bless \{},shift;
}

sub commonlyusedfunction
{
        # do stuff
}

sub rarelyusedfunction
{
        my $self = shift;
        my $cl = Foo::CodeLoader->new();

        $cl->load('DDS');

        my $dds = Data::Dump::Streamer->new;
        $dds->Dump($self)->Out();

}

package Foo::CodeLoader;

sub new
{
        my $class = shift;
        my %modules = (      DDS        =>      'Data::Dump::Streamer'
+    );
        return bless \%modules,$class;
}

sub load
{
        my $self = shift;
        my $param = shift;
        eval "require $self->{$param}";
}

sub list
{
        my $self = shift;
        for (values %{$self})
        {
                print "$_\n";
        }
}


1;
[download]

Although I'm always slightly uncomfortable with eval require

You seem to be reinventing autouse, which has been in the distro since 5.6, if I recall.

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

Thanks, I hadn't come across autouse before, and it would certainly solve the problem of scattering requires through ones code to have:

use autouse 'This::Module';
use autouse 'That::Module';
[download]

At the top of the code. Interestingly though, autouse fails in this particular instance where my quick (and perhaps OO centric) kludge up didn't, because DDS implements an import method:

autoused module has unique import() method at autouse.pl line 5
[download]

with the following code:

use strict;
use warnings;

use autouse 'Data::Dump::Streamer'=>qw(Dump);
use autouse 'No::Such::Module';

print "foo\n";

my %hash = (    1=>'one',
                2=>'two',
                3=>'three'      );

Dump(%hash);

my $dds = Data::Dump::Streamer->new;

$dds->Dump(%hash)->Out();
[download]

Note: I'd tried both OO & non OO interface, hence the inclusion of two calls to Dump - with the Dump(%hash); line commented out it fails with:

Can't locate object method "new" via package "Data::Dump::Streamer" (p
+erhaps you forgot to load "Data::Dump::Streamer"?) at autouse.pl line
+ 15.
[download]

--------------------------------------------------------------

"If there is such a phenomenon as absolute evil, it consists in treating another human being as a thing."

John Brunner, "The Shockwave Rider".

The meta module is an interesting idea - some mechanism for loading & keeping a list of potentially required modules.

That kind of thing -- lazy importing/on-demand functions -- is on my TODO list for ToolSet. If there's a lot of demand for it, I'd be willing to bump it up on my "get around to it" list. I was thinking of exporting a stub function that, if called, would require the real module if it hadn't been loaded already and from then on just directly goto the real function whenever called.

-xdg

Code written by xdg and posted on PerlMonks is public domain. It is provided as is with no warranties, express or implied, of any kind. Posted code may not have been tested. Use of posted code is at your own risk.

A minor comment on the call to DDS:

sub rarelyusedfunction
{
        my $self = shift;
        my $cl = Foo::CodeLoader->new();

        $cl->load('DDS');

        my $dds = Data::Dump::Streamer->new;
        $dds->Dump($self)->Out();

}
[download]

I would write that as follows:

sub rarelyusedfunction
{
        my $self = shift;
        if ( eval { require Data::Dump::Streamer; 1 } ) {
           return scalar Data::Dump::Streamer::Dump($self)->Out();
        } else {
           warn "**DANGER** Falling back to Data::Dumper as DDS"
                . " isn't available";
           require Data::Dumper;
           return Data::Dumper::Dumper($self)
        }

}
[download]

The scalar there is useful, as Out() behaves differently in list and scalar context (something that was probably a mistake in hindsight and which might change in the next release, I've been putting serious consideration into changing the interface somewhat in version 2).

I've never bothered with any Autouse stuff personally. The pattern

if ( eval { require Foo; 1 } ) { .. } else { ... }
[download]

is simple enough I think.

---
$world=~s/war/peace/g