#!/usr/bin/perl
use strict;
use warnings;
#by Abigail of perlmonks
# example usage: $0 IO::File

my $class = shift or die "need a class\n";

eval "use $class";
die $@ if $@;
   
# First, find all the classes, and the ones it inherits.
my %classes = ($class => 1);
my @classes = ($class);
   
while (@classes) {
   my $class = pop @classes;
   no strict 'refs';
   foreach my $class (@{"$class\::ISA"}) {
       next if $classes {$class} ++;
       push @classes => $class;
   }
}

# Then find the subs in those classes.
while (my $class = each %classes) {
   no strict 'refs';
   print "From class '$class':\n";
   while (my $entry = each %{"$class\::"}) {
       print "\t$entry\n" if defined &{"$class\::$entry"};
   }
}  
__END__
[download]

my @subs;
{
    no strict 'refs';
    my $st = $class . '::';
    @subs = keys %$st;
}
[download]

Unfortunately, there's no way to differentiate between methods and regular subroutines, and as moritz pointed out, that won't find inherited methods which exist in different packages. Moose's metaclass facilities are really great, but naturally they only work for objects that are built with Moose.

There is Class::Inspector, which has a reasonably good function to search a class's @ISA tree and get a list of every possible inherited method.

This will work with any Plain Old Perl Package, no Moose-ness required.

my @methods = Class::MOP::Class->initialize('Class::Name')->compute_al
+l_applicable_methods;
[download]

• method name
• the name of the class in which the method lives
• a Class::MOP::Method instance that contains the CODE ref for the actual method

Without having checked, I think your code will fail to list method in superclasses of $object

(And shouldn't $result be really $object?)

> Use Moose or another OO framework that allows easy introspection.

Hmm ... but nothing for the old-fashioned plain blessed packages?..

> Without having checked, I think your code will fail to list method in superclasses of $object

You're right :(

> And shouldn't $result be really <c>$object?

Of course it should :)

Class::MOP (which is the foundation of Moose) works well with the "old-fashioned" plain blessed hashref packages and has the functionality you are looking for. It is provided via Class::MOP::Class method_map.

Hmm ... but nothing for the old-fashioned plain blessed packages?..

I think you can do better (for example recurse into the classes @ISA, and filter out methods beginning with an underscore (which are private by convention), DESTROY etc.), but there are conceptual limits.

Perl doesn't have different declarations for subs and methods, so it's impossible to distinguish these two automatically.

Maybe there are better solutions to your problem. For example the thread Runtime introspection: What good is it? discusses (among a variety of other things) possible alternatives to to introspection.

You don't specify, but if what you're after is a debugging tool, rather than something that you want to integrate into other code, then use the Perl debugger:

    perl -d -MDBI -e 5
    > $d = DBI->new();
    > m $d                      # or just "m DBI"
[download]

This returns: