#!/usr/bin/perl

use warnings;
use strict;

package Class;

sub new { bless {}, $_[0] };

1;

package Class::SubclassA;

sub new { bless {}, $_[0]; };

1;


package Class::SubclassB;

sub new { return bless {}, $_[0]; };

1;

package ClassFactory;

my %creation_hash = (
  SubclassA => sub { Class::SubclassA->new() },
  SubclassB => sub { Class::SubclassB->new() }
);

sub create {
  shift;
  print $creation_hash{$_[0]}, "\n";
  return $creation_hash{$_[0]}->();
}

1;
package main;

my $a = ClassFactory->create( "SubclassA" );
my $b = ClassFactory->create( "SubclassB" );

print $a, "\n";
print $b, "\n";
[download]

Don't hardcode the daughterclass names, or else you won't be able to subclass the factory class. Instead, call a method that returns the daughterclass name:

sub TypeA { return "Class::SubclassA" }
sub TypeB { return "Class::SubclassB" }
sub create {
  my $class = shift;
  if (shift eq "B") {
    return $class->TypeB->new(@_);
  } else {
    return $class->TypeA->new(@_);
  }
}
[download]

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

There isn't much of a penalty on eval STRING when it's a simple statement like use. Not compared to the time it takes to load the module! :)

You can always use require, but you first have to perform a transform on the module name (this is a design bug which is tidied in Perl 6):

  my $module = "Some::Class";
  $module =~ s{::}{/}g;
  $module .= ".pm";
  require $module;
[download]

There will be a cargo cult disapproving of require, be sure to poke your tongue out at them, laugh and ask them why until they say "'coz" :-).

You can also look at Class::Tangram::Generator for an example of code that defers loading of modules until objects of the relevant type are created, using several different mechanisms.

$h=$ENV{HOME};my@q=split/\n\n/,`cat $h/.quotes`;$s="$h/."
."signature";$t=`cat $s`;print$t,"\n",$q[rand($#q)],"\n";
[download]

Am I going to have to eval "use ..." and suffer the consequences?

Pretty much. If you don't want to load the modules until runtime then you're going to have to use one of use, require or do. There are some CPAN modules like Class::Factory that wrap up most of the hard work for you .

my $s = 'Dog';
my $class = 'My::Pets::' $s ;

use Class::Runtime;
my $cl = Class::Runtime->new( class=> $class);
$cl->load unless $cl->isLoaded;
my $obj = $class->new;
[download]