my %RefTypes = (
   'Regexp' => \&HandleRegexp,
   'CODE'   => \&HandleCodeRef,
   'ARRAY'  => \&HandleArrayRef,
   'HASH'   => \&HandleHashRef,
   'SCALAR' => \&HandleScalarRef,
   ''       => \&HandleScalar,  
);

my $ref = ref($_);
if(exists $RefTypes{$ref}) {
   $RefTypes{$ref}->($_);
} else {
   warn "Unknown ref() wth is a $ref ?!";
}
[download]

Just for reference using a hash this way is called a dispatch table.

                - Ant
                - Some of my best work - (1 2 3)

You could also use the reftype function from Scalar::Util. This has the advantage of

1. Explicitly returning undef on a non-reference variable
2. Returning the underlying data structure type when handed an object

for example:

use Scalar::Util qw(reftype);

my $o=bless {},MyClass;

print ref $o       # prints "MyClass"
print reftype($o)  # prints "HASH"
[download]

But, I would rethink what you're doing if you have to do this. Especially, if you're doing this for configuration purposes. How on earth are you planning on persisting a CODE or Regexp reference in your configuration?

Data::Dump::Streamer can be used to serialize subroutines and closures properly under sane scenarios. (Yes you can deliberately craft a set of closures that will not dump properly, but it should be quite rare in practice as it would require using unwise var naming practices in the first place.)

As for regular expressions, DDS can serilize them properly as well so long as they don't include (?{}) and (??{}). In other words regexes that arent closures are properly handled. Ill have to make a stab at handling regex closures in a future release.

PS: i think you meant "SCALAR" and "REF", there is no perl type "SCALARREF". :-)

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

When i have had to do this its looked much like you have posted. However as others have pointed out you will have issues with using ref() for this task. And unfortunately reftype() isn't a complete solution to the problem as 'Regexp' is unfortunately not treated as a native Perl type but rather as a blessed scalar reference. Thus reftype(qr/./) will return SCALAR not "Regexp".

In Data::Dump::Streamer I provide some utility XS methods that make this job a little easier. Data::Dump::Streamer::reftype() is similar to that provided by Scalar::Util except it returns PL_no (false) instead of undef which means you don't have to bother with a checking if the response is defined. A simple (if reftype($foo) eq 'SCALAR') will not raise a warning.

A second utility function of interest is Data::Dump::Streamer::regex() which in list context returns a list containing the regex pattern (without quoting or '(?:)' wrapper) and the modifiers on the pattern, and in scalar context returns the same as a stringified qr// would. This routine can not be fooled by blessing the qr// or by overloading its stringification logic (which says to me that regex's are native types distinct from normal SCALAR's and that they should receive a unique reftype designation)

So the logic would look something like this:

use Data::Dump::Streamer qw(reftype regex);

my $type=reftype($obj);
if ($type eq 'SCALAR' and my $re=regex($obj)) {
   # Its a regex, $re contains the unquoted pattern
} elsif ($type eq 'REF' or $type eq 'SCALAR' or $type eq 'GLOB') {
   # its something that can be derefed by $$obj
} elsif ( $type eq 'HASH' )
   # its a hash
} elsif ( $type eq 'ARRAY' )
   # its an array
} elsif ( $type eq 'CODE' )
   # its code ref
} elsif ( $type eq 'FORMAT' )
   # its a format ref
} elsif ( $type) {
   warn "Unhandled type: '$type'\n";
} else {
   # its not a reference at all
}
[download]

For my uses I never found a dispatch table to be worthwhile. I think the overhead of doing the lookup and dispatch is more than doing the string comparisons in this case. For a larger dispatch table it might be worth while tho. You'd have to benchmark to see.

Of course, the overhead difference is hardly such that your typical Perl program would suffer, but certainly if you are being speed conscious. Especially since you can arrange your constructs so that the most common options come first.

I often prefer dispatch for the ease of adding new items.

                - Ant
                - Some of my best work - (1 2 3)

ref() can return anything for blessed objects

perl -le 'print ref(bless{},"Hello World")'
[download]

Scalar util's reftype is better for this job.

Except that it (Scalar::Util::reftype()) can't tell a regexp from a ref to a scalar.

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