A subroutine can only return a scalar or a list. What the caller does with the result is completely out of the subroutine's control.

sub array {
  return 0 .. 5;
}

my %hash = array();
[download]

However, you _could_ do something like the code below, but it's pretty strange stuff and I'm not sure how useful it is :-)

#!/usr/bin/perl -w
use strict;

sub get_stuff {
  my $ref = shift;

  if (ref $ref) {
    if (ref $ref eq 'SCALAR') {
      $$ref = 'This is a scalar';
    } elsif (ref $ref eq 'ARRAY') {
      @$ref = qw(This is an array);
    } elsif (ref $ref eq 'HASH' ) {
      %$ref = (1 => 'This',
           2 => 'is',
           3 => 'a',
           4 => 'Hash');
    } else {
      die "Invalid reference type passed to get_stuff.\n";
    }
  } else {
    die "Non-reference passed to get_stuff.\n";
  }
}

my ($scalar, @array, %hash);

get_stuff(\$scalar);
get_stuff(\@array);
get_stuff(\%hash);

print "$scalar\n";
$"='|';
print "@array\n";
print map { $hash{$_} . ' ' } sort keys %hash;
[download]

sub test {
  if (wantarray){
    return 'One String';
  } else {
    return ('A', 'List', 'of', 'Strings');
  }
}
[download]

The DBI module uses a similar technique (non-relevant code removed for brevity):

sub fetchall_arrayref {
    my $slice= shift || [];
    my $mode = ref $slice;
    if ($mode eq 'ARRAY') {
        push @rows, [ @$row ] while($row = $sth->fetch);
    }
    elsif ($mode eq 'HASH') {
        push @rows, $row while ($row = $sth->fetchrow_hashref);
    }
    else { 
        Carp::croak("fetchall_arrayref($mode) invalid") 
    }
    return \@rows;
}
[download]

  $sth->fetchall_arrayref( [] ) # returns Array references
  $sth->fetchall_arrayref( {} ) # returns Hash  references
[download]

Cool stuff!

Russ

$var = mysub();
@var = mysub();
%var = mysub();

sub mysub {
    print "You want a scalar\n" unless wantarray;
    print "You either want a hash or an array\n" if wantarray;
}
[download]

my($var,@var,%var);

&mysub(\$var);
&mysub(\@var);
&mysub(\%var);

sub mysub {
    my($ref) = shift;
    print "You want a scalar\n" if ref($ref) eq 'SCALAR';
    print "You want an array\n" if ref($ref) eq 'ARRAY';
    print "You want a hash\n"   if ref($ref) eq 'HASH';
}
[download]

I think this is an XYZ question. The interface design question is backwards.

Instead of asking, "What kind of information does this subroutine return?" he's asking "What kind of information does the caller want?"

The only place where this question might fit is when you're replacing an existing subroutine, and the interface already takes context into account. (Pointing out wantarray takes care of that.)

In short, I'm terribly confused by this question altogether, and very curious as to what lead to it.

A subroutine can return only single value. That value could be scalar or reference of variable. If we want to return scalar(single) variable then we can do like..
return $a;
If want to return array list or hash list then we need to return reference of array or hash Consecutively like..
return \@name_of_array_variable;
return \%name_of_hash_variable;

Hope this will resolve the issue.

Originally posted as a Categorized Answer.