@array1 = get_array2() || ();

The problem with this statement is that the  || (logical-or) operator causes  get_array2() to be invoked in scalar context. So, of course, evaluation of  @array2 in the return statement of the function is in scalar context and you get the number of elements of the array as the returned value.

There may be a conceptual disjunction here: while a scalar can be undefined or hold an empty string (or a few other things), an array only ever holds zero or more scalar elements. There is no such thing as an "undefined" array. (Update: Of course, an array element, if any exist, is always a scalar, so you could have an array with one or more undefined elements.)

Update: Take a look at Context tutorial in the PerlMonks Tutorials.

Update 2: Another conceptual problem with the quoted statement is rooted in the fact that a function only returns a list of zero or more elements. So what the statement is saying (or trying to say) is "assign the return list of the function call to the array unless the list is empty, in which case assign the literal empty list," which kinda doesn't make a lot of sense.

Update 3: Changed "zero or more elements" to "zero or more scalar elements" in second paragraph above just for sake of clarity.

Hi gregzartman,

You've already got some good replies (it's all about Perl's concept of context); just to provide a different angle: what do you want the variables to hold?

When you write my $foo;, the variable initially holds undef, and it's understandable and common to write something like $foo = func() // ''; (that is, set $foo to the scalar return value of func(), but when that return value is undef, set $foo to the empty string instead). Whether it's good practice depends on the situation; the point of this might be to prevent later warnings about $foo being undefined when interpolated into a string, (Update 2:) or to detect whether $foo has been assigned to or not. Note that the // defined-or operator became available in Perl 5.10.

However, when you write my @bar;, that variable doesn't contain undef, it simply contains zero values. Also, a function which returns a list or array would normally not return undef to mean "no results", it would return an empty list*. So there is no need to do something like "assign an empty value to an array if the function doesn't return anything", since the array will simply continue to contain zero values, and there are no warnings about that.

Now, a different question might be: what if a function returning zero values were to represent an error condition that you wanted to detect? To do that, I would suggest to first fetch the return value of the function into an array, and then test it, for example: @bar = func2(); if (!@bar) { warn "func2 returned nothing" }.

* Update 2: Some really interesting discussions come up when you search for "return undef", for example this thread seems to be very relevant, also this one.

Hope this helps,
-- Hauke D

Updated: Typo fix and minor rewordings.

Mostly for the sake of the OP and anyone else who thinks error return codes are a good idea.

The old school technique of returning a special value to indicate an error condition is kinda OK, but far better is to throw at the point the error condition is raised. That makes tracking down bugs related to detected errors much easier. The down side with ignoring errors is you may never notice the error condition and the code will quite happily complete - often very fast. That is of course an excellent outcome if you don't care that the result is bogus.

In cases where you know that something may fail but really don't care, wrap the called code in an eval and ignore the error. At least then you are explicitly ignoring the error rather than maybe just forgetting to test the result.

Premature optimization is the root of all job security

Thanks for all the great replies guys. What you have explained confirms what I thought was going on

Hauke, as you point out the issue is with undef. In some of the places in the API I'm working with an undef scalar can throw perl warnings in the log files. The simple solution is to just do:

 @array2 = a_sub_that_returns_a_list || '';

My main reason for asking the question was to understand what perl was doing with the || in the context I was using it and you guys have explained it well. Thanks!

Hi gregzartman,

The simple solution is to just do:

@array2 = a_sub_that_returns_a_list || '';
[download]

As AnomalousMonk explained, I doubt that code will do something that is useful for you...?

Why not just do

@array2 = a_sub_that_returns_a_list();
[download]

?

Regards,
-- Hauke D

$var = some_class->some_method() || ''

So, in most cases, the downstream code wants a scalar to either be some value or an empty string. The downstream code wants an array to either be some non-empty array or an empty array.

Now, maybe, I have obtained some subroutines or methods that return scalars and other subroutines or methods that return arrays. I want to use those subroutines or methods without modifying them because, if I change them, I might make a mistake and then they won’t do what I thought they were supposed to do (and everyone else on the project thought they would do).

So, wouldn’t it make sense to wrap those subroutines or methods in a subroutine that will make sure that the downstream code gets what it expects?

sub somefunc_for_scalars {
    my $answer = some_class->some_method();
    return defined($answer) ? $answer : ''; 
}
[download]

Digression: If the reader wants to use Perl's // operator in the return statement, go ahead. However, it may confuse other programmers. See http://stackoverflow.com/questions/23873379/what-does-the-double-forward-slash-mean-here for a nice explanation of Perl's // operator, which is available with Perl 5.10 or later.

sub somefunc_for_arrays {
    my @answer = get_array2();
    return @answer; 
}
[download]

However, somefunc_for_arrays is superfluous if it is correct for get_array2() to return some non-empty array or an empty array.

In some rare instances, the downstream code does not want an empty array. So, code somefunc_for_arrays thusly:

sub somefunc_for_arrays {
    my @answer = get_array2();
    if (!(scalar @answer)) { die 'get_array2() returned an empty array
+.' }.
    return @answer; 
}
[download]