sub subref
{
  my $self = shift;
  return {
    order => ['A', 'B'],
    dispatch => {
      A => sub { $self->suba(@_) },
      B => sub { $self->subb },
    }
  };
}
[download]

    dispatch => {
      A => sub { $self->suba(@_) },
      B => sub { $self->subb(@_) },
    }
[download]

Two comments:

Data::Dumper may not be the best way to Dump closures, I find Data::Dump::Streamer a lot more useful:

foo.pl

#!/usr/bin/perl
use strict;
use warnings;
use Data::Dump::Streamer; ##!!

use Foo;

my $help   = 'Please display this message';
my $foo    = Foo->new;
my $subref = $foo->subref;

foreach my $pos (@{$subref->{order}}){
  my $sub = $subref->{dispatch}->{$pos};
  Dump ($sub);  ###!!
}
[download]

Outputs:

my ($self);
$self = bless( {}, 'Foo' );
$CODE1 = sub {
           package Foo;
           use warnings;
           use strict 'refs';
           $self->suba;
         };

my ($self);
$self = bless( {}, 'Foo' );
$CODE1 = sub {
           package Foo;
           use warnings;
           use strict 'refs';
           $self->subb;
         };
[download]

This seems clearer to me than the output you got from Data::Dumper. And maybe you would catch the error that rhesa points out.

And since you already broke the encapsulation of your object, why don't you return the plain function instead of a method?:

package Foo;
use strict; use warnings;

sub new { bless {}, shift; }
 
sub suba 
{ 
#  my $self  = shift;
  my $param = shift || '';
  print "Message is: $param\n";
}

sub subb { return; }

sub subref
{
  my $self = shift;
  return {
    order => ['A', 'B'],
    dispatch => {
      A => \&suba, ##!
      B => \&subb, ##!
    }
  };
}

1;
[download]

Outputs (as expected)

POS: A
$CODE1 = sub {
           package Foo;
           use warnings;
           use strict 'refs';
           my $param = shift @_ || '';
           print "Message is: $param\n";
         };
Message is: Please display this message
POS: B
$CODE1 = sub {
           package Foo;
           use warnings;
           use strict 'refs';
           return;
         };
[download]

citromatik

Using Data::Dumper is just habit. Maybe I should re-evaluate some of my habits.

And since you already broke the encapsulation of your object, why don't you return the plain function instead of a method?

I need the methods to have all the inherited properties of the object they live in (multiple inheritance, including Class::Accessor in the base class). Can I get that from a plain function?

-=( Graq )=-