Truth and Falsehood

Thanks for this useful node.

• An empty array, which evaluates to the number of elements it contains, i.e. zero (0).
• An empty hash, which evaluates to a false value when it is empty.

I've tested empty hashes on several perls here and they, like empty arrays, always appear to evaluate to zero as well. Is there a reason why you have expressed them differently here?

I've tested empty hashes on several perls here and they, like empty arrays, always appear to evaluate to zero as well. Is there a reason why you have expressed them differently here?

Just because that's what the Perl documentation says. perldata:

If you evaluate a hash in scalar context, it returns a false value if the hash is empty. If there are any key/value pairs, it returns a true value.

I see - thank you. Interestingly the very next sentence in perldata is:

A more precise definition is version dependent.

which suggests that there may be some versions out there where the false value returned is not zero (or that there may be in future, intriguingly). I'll have to try to remember only to test the truth of empty hashes rather than their numerical value. :-)

While I know that you did not label this "[RFC]", this looks like a good draft for a brief tutorial.

As currently written, this neglects $#array. I think it would be better to write the first paragraph in "Hash and Array Size" as:

To get the number of elements in an array, use scalar, as in scalar @array, or use the array in a scalar context, for example my $size = @array;. To test whether an array is empty or not, simply use it in a boolean context, such as if (@array). To get the largest index in an array, use $#array. To explicitly resize an array, assign a value to $#array. Perl normally grows arrays as needed, but explicitly assigning to $#array can also shrink an array, discarding elements from the high end.

I have tried to follow your style in the above text, but I expect that you will further edit that before using it, if you use it.

The exists and defined tests also apply to array indexes, in the same way that they apply to hash keys. This can be explained briefly and would go well with adding mention of $#.

And one minor stylistic quibble: I think of exceptions as "thrown" with die because they can be "caught" with eval BLOCK, but can warnings be similarly "caught" in Perl or would it be better to say that length returns undef without producing a warning?

While I know that you did not label this "[RFC]", this looks like a good draft for a brief tutorial.

The intent was a little different, as I mentioned at the very bottom of the node: There used to be a section "Truth and Falsehood" in perlsyn that was nice and short, and easy to link to whenever someone's question touched on Perl's concept of true/false, but that section was merged into a much longer block of text in perldata, which IMHO makes it harder to provide a link to people who just want to know about that one topic. (The title is such that it's easy to link to as [Truth and Falsehood].) So I want to keep the main point of the node focused on just true/false, hence I tried to separate out the "Related Topics" so that the top is just a "TL;DR".

As currently written, this neglects $#array.

Yes, that's a good point, I'll add a brief mention of it, thanks. IMHO, the more detailed description you wrote starts getting a little off-topic to the main point of the node, so I'll keep it a little shorter.

The exists and defined tests also apply to array indexes

Not entirely; from exists:

WARNING: Calling exists on array values is strongly discouraged. The notion of deleting or checking the existence of Perl array elements is not conceptually coherent, and can lead to surprising behavior.

would it be better to say that length returns undef without producing a warning?

Yes, good point, thanks!

the more detailed description you wrote starts getting a little off-topic

Fair enough, and the link to the reference manual makes up for trimming it.

[for exists on arrays]

The tests apply, even though the results can be surprising, mostly due to the fact that Perl's arrays have a contiguous range of index values. I suspect that exists $array[$i] is equivalent to $i <= $#array. If not, then that is really surprising and probably better left "under the rug". :-)

perl -M5.27.6 -e '$_=`perldoc -Tt perldata`;s/.*(A scalar.*?way).*/$1.
+/s;say'
[download]

You might want to add that for dualvars, it is the stringy part of the value which is tested for truthfulness.

use Scalar::Util 'dualvar';

dualvar(1, "0");  # false
dualvar(0, "1");  # true
[download]

The empty list (), which evaluates to undef.

When's the last time you did if (()) {}? Why would you ever do that?

I suppose one could use sub f { return (); } if (f()) {}, but that's a very bad practice. (A sub that's expected to return a scalar should do so even in list context.)

So I'm rather baffled as to why this was mentioned. There are so many operators that can return false that would merit a mention before (), such as scalar assignment, list assignment, grep, map, m// and s///.

I suppose one could use sub f { return (); } if (f()) {}, but that's a very bad practice. (A sub that's expected to return a scalar should do so even in list context.)

I agree that subs that are expected to return a scalar should do return undef because of the problems with my %hash = ( k => f() );, but there are also some good arguments against return undef in other cases - as you've said, there are exceptions.

I mostly mentioned it because the old section "Truth and Falsehood" mentioned it, although with an attempt to improve the wording, as you've suggested yourself in the past.

Update: I missed your ninja edits, but I hope I've cleared up your bafflement nonetheless. Please feel free to add any information you think is missing!

Logically, operators like grep, map, m//, and s/// all return false by returning an empty list, at least in a simple description.

That makes no sense. An empty list isn't false. Or true. It's not a scalar, so those concepts don't apply to it. You can't evaluate whether an empty list is true or false. You can only evaluate if a scalar is true or false.

As such, if you're trying to get a true or false value from those operators, you would be evaluating them in scalar context, and the following is what the listed operators actually return in scalar context:

• grep returns the count of matching elements.
• map returns the count of elements it would return.
• m// and s/// return success or not.

The "special false" is dual valued. You can reproduce it like this:

$false = '';
$foo = $false + 0;
[download]

Or more explicit:

use Scalar::Util 'dualvar';
$false = dualvar(0, '');
[download]

Or just !1 ;-)