Since the only thing you're doing with the created package is setting its inheritance chain in @Package::ISA, you can do that directly:

sub inherit_from_A {
  my $package_name = shift;
  no strict 'refs';
  @{"${package_name}::ISA"} = qw(A);
}

# create class B1..
inherit_from_A('B1');
[download]

Does Re: Creating packages on the fly come close to what you want to do? At the very least it does contain code that creates a new package dynamically.

/J\

If you need to generate these classes dynamically at runtime, then you could use the technique Joost suggested. However, if you have a fixed set of classes which you know at compile time, and are basically just looking to save your wrists from having to type things over and over, then you could use Module::Compile::TT to just expand the code you need at module load time (actually pre compile-time phase).

package A;

# ... code here

use tt ( subclasses => [ map { 'B' . $_ } 1 .. 100 ] );

[% FOREACH subclass IN subclasses %]
    package [% subclass %];
    our @ISA = qw(A);
[% END %] 

no tt;
[download]

StaticMammal.pm (The equivalent of your A):

#!/usr/bin/perl -wT

package StaticMammal;

use strict;
use warnings;

sub new {
    my ($class) = @_;
    my $new_critter = bless {}, $class;
    return $new_critter;
}

sub walk {
    my ($self) = @_;
    print "A " . ref( $self ) . " walks " . $self->walks_how() . "\n";
    return;
}

sub talk {
    my ($self) = @_;
    print "A " . ref( $self ) . " says " . $self->talks_how() . "\n";
    return;
}

sub walks_how {
    return q(ponderously);
}

sub talks_how {
    return q(Grrr);
}


1;
__END__
[download]

#!/usr/bin/perl -wT

package DynamicMammals;

use strict;
use warnings;

use lib '.';

my %style_of
    = (
       Cat => {
           talks => q(meow),
           walks => q(in beauty, like the night),
       },
       Dog => {
           talks => q(woof),
       },
       FrankenMammal => {
           ## empty hash
       },
       );

my $package_str = q();
foreach my $mammal (keys %style_of) {
    $package_str .= qq(
                       package Dynamic$mammal;
                       use base qw(StaticMammal);
                       );
    my $action_href = $style_of{ $mammal };
    foreach my $action (keys %$action_href) {
        $package_str
            .= sprintf q(
                         sub %s_how {
                             return q(%s);
                         }
                         ), $action, $action_href->{ $action};
    }
}

eval $package_str;
if (my $msg = $@) {
    die "Eval error: $msg\nwhile trying to eval:\n$package_str";
}


1;
__END__
[download]

#!/usr/bin/perl -wT

use strict;
use warnings;

use lib '.';
use DynamicMammals;

my $felix = DynamicCat->new();
my $spot  = DynamicDog->new();
my $thing = DynamicFrankenMammal->new();

foreach my $critter ($felix, $spot, $thing) {
    $critter->walk();
    $critter->talk();
}

__END__
[download]

Lots of great ways to do it - but this smells of an XY Problem to me. As in, why does package A inspect $self? I can imagine a few cases where this may be desirable (especially with dynamic subclasses - subclasses where the name is part of the data), although even then it's kinda suspect (just put the name in the $self hash).

In general, inheritance is done by simply putting overridable actions in their own subs, and then letting each package override the appropriate methods in the appropriate ways. No introspection required. Of course, you don't need to put them in separate files, either, but that's up to you.

Your comment says:

# much base code which Does The Right Thing based on subclass type
# thru ref($self) inspection
[download]

I've never needed to do this in normal code. What are you doing that normal polymorphism is not enough?