One of the interesting things about Perl is that what a subroutine returns is determined by the context in which it is called:

#!/usr/bin/perl

use warnings;
use strict;

sub foo { 
    my @water = qw(heavy normal polluted);
    @water;
}

my $bar = foo();
my @baz = foo();

print "Bar : $bar\n";
print "Baz : @baz\n";
[download]

with "bar", the interpreter sees that it's assigning the returned value to a scalar (the call is made in scalar context), so it gives you the size of the list it returned -- as a matter of fact, you'd get the same result with  my $bar = scalar foo();, so your code isn't doing what you expect. With "baz", it sees that it's assigning the returned value to an array (list context), so it assigns the members of the list it's returning to the array. (BTW, this sort of behavior is changing radically in Perl 6). If your sub returns a scalar, and you assign it to an array, what you get is a one member array. So, to a large extent, you get what you ask for from the subroutine. Perl (v. 5, anyway =) just isn't the kind of language that tries to enforce the distinction you're looking to enforce.

By the way, you can check for the calling context within the subroutine with wantarray. HTH

I mistrust all systematizers and avoid them. The will to a system shows a lack of integrity -- F. Nietzsche

Also, in your title, you suggest that you want the function to return an array, but in the text, you talk about returning a list. A list, and not a scalar. But this is very confusing. First, a function can not return an array. A function returns either a scalar, or a list. What it returns is determined by the context, and the context alone. A scalar will be returned in scalar context, and a list will be returned in list context. The return @x in the test function never returns an array - it returns a scalar in scalar context, and a list (consisting of the elements of @x) in list context.

BTW, what is your fear of modules?

Abigail

Ok, I'll try a better translation from my thoughts in italian to a better english :-)

Maybe I should restate the question this way:

is it possible , and how, to distinguish if a sub/method is returning a single scalar (

return
$this
[download]

, which my test script should consider wrong) or a list (return ($this) or return qw(a bunch of values)) or an array (return @this) which my test script should both consider good?

I'm writing a test script (one of those that make test runs) that checks if a class of mine or a subclass of it behaves like it should.

My check detects the case return @this but fails on return qw(this list).

use strict ;
use warnings ;

sub test {  return ('a','test') }

my $test = test() ;
my @test = test() ;

print ">>> $test\n" ;
print map "[$_]\n",@test ;
print $test == scalar(@test)? "Yepa!\n" : "Nope!\n" ;
[download]

This one fails:

$ perl test.pl
>>> test
[a]
[test]
Argument "test" isn't numeric in numeric eq (==) at test.pl line 11.
Nope!
[download]

(even if I consider test's return value ok for my class...)

I hope I explained now. Do I?

Ciao!
--bronto

# Another Perl edition of a song:
# The End, by The Beatles
END {
  $you->take($love) eq $you->made($love) ;
}

Yes, you explained what you want. It's also clear you lack some fundamental knowledge about Perl. You need to make yourself more familiar with the concept context. A subroutine will return a list if and only if it was called in list context. A subroutine will return a scalar if and only if it was called in scalar context. A subroutine will return nothing if and only if it was called in void context. The crucial point is that it is the context that determines whether the subroutine returns a list or a scalar - not the subroutine.

Furthermore, parenthesis do not create lists (except in some very specific syntax constructs). Parenthesis are used for grouping.

    return $this;
    return ($this);
    return (($this));
    return ((($this)));
[download]

all mean the same. The do not differ just like there is no difference between:

    3 + 4;
    (3 + 4);
    (3) + (4);
    ((3) + (4));
[download]

As for

    return @x;
[download]

that will return the number of elements of @x in scalar context, and a list consisting of the elements of @x in list context. Perl will never return an array. You can check for yourself:

    my @x = qw /foo bar baz/;
    sub my_func {return @x};
    (my_func) [1] .= "hello";
[download]

This gives a compile error:

    Can't modify list slice in concatenation (.) or string
[download]

Note that it says "list slice". A list, not an array.

Abigail

use strict ;
use warnings ;

sub test {
    return wantarray ? qw(test) : scalar @{[qw(test)]};
}

my $test = test() ;
my @test = test() ;

print ">>> $test\n" ;
print map "[$_]\n",@test ;
print $test == scalar(@test)? "Yepa!\n" : "Nope!\n" ;

__output__

>>> 1
[test]
Yepa!
[download]

_________
broquaint

When you return @x into scalar context, you get the number of elements in @x. (Aside: to return the "right thing" in whatever context the user called, use wantarray) So, your test will always work, because you are doing the same thing twice.

If you don't want a reference, test against ref. If you want to prove you only returned one value (or you returned > 1), assign to an array and test with scalar, as you are.

Perhaps you should ask, "Why do I care if I have a list/array vs a scalar value?" There is no difference between your example (returning one value) and return 'test' (also one value) (except, of course, your array will not return 'test' into scalar context...).

Does it really matter, as long as you get one or more correct values?

Russ
Brainbench 'Most Valuable Professional' for Perl