for sure in your research you read create-your-own-dualvars

Ha ha, this has now become hilarious!

Yesterday in Re^3: Rosetta Code: Long List is Long (Updated Solutions - dualvar), I claimed "Despite using Perl for 20 years, I'd never heard of dualvar before" ... yet on seeing your reference to good old brian_d_foy's dualvar article just now, I rushed to my bookshelf to find brian's superb book still sitting there, along with my customary book notes scribbled on a piece of paper inside the book ... which noted the existence of dualvar on page 30 as "interesting"! Oops, looks like my memory is starting to fail.

Also interesting is that the paper copy had some nice levity to it which is sadly missing from the Web version ... at least the paper copy concludes the dualvar item with "now that you know this, don't start using it everywhere. Save it for very special situations, like impressing people at conferences and cocktail parties." ... or impressing people at Perl Monks in the case of marioroy. :)

I used "dualvar" also, in MCE::Shared::Cache. When max_age is specified during construction of the cache, the dualvar is used internally to store the expiration time with the key name in the keys array.

# update expiration
$keys->[ $off ] = ( $exptime >= 0 )
   ? dualvar( time + $exptime, $_[1] )
   : dualvar( -1, $_[1] );
[download]

Basically, the "dualvar" capability in Perl allows the "max_age" feature without increasing the memory consumption of the cache or impacting performance.

Interesting!

In computer programming, a semipredicate problem occurs when a subroutine intended to return a useful value can fail, but the signalling of failure uses an otherwise valid return value. The problem is that the caller of the subroutine cannot tell what the result means in this case.

The division operation yields a real number, but fails when the divisor is zero. If we were to write a function that performs division, we might choose to return 0 on this invalid input. However, if the dividend is 0, the result is 0 too. This means there is no number we can return to uniquely signal attempted division by zero, since all real numbers are in the range of division.

-- from Semipredicate problem (wikipedia)

Vaguely related is C++-17's std::variant and Haskell's Type Inference system, with types like Maybe Real and Either String Char.

So perhaps we can say that Perl's dualvar helps solve the Semipredicate problem ... though admittedly, without dualvar, ordinary Perl scalars can use undef to signal invalid input.

I'm not an expert on any of this, just coincidentally happened to be looking at this topic while updating my notes on exception handling vs error returns in functions. :) Ideas/corrections and other cool references on this topic welcome!

References Added Later

• Why do we need Monads? (SO) - describes rationale for Maybe Real in Haskell, namely to signal errors in a language using functions only (i.e. without Exception handling), where their solution is to allow functions to return two kinds of things
• Result type (wikipedia) - in Haskell, Either type; in C++, std::expected<T, E>; in Rust, enum Result<T, E> { Ok(T), Err(E) }
• Hash value test of zero (mentions Larry's infamous "0 but true" and "0E0", which evaluate to 0 as a number, but true as a boolean)
• Re^3: Rosetta Code: Long List is Long (Updated Solutions - dualvar) (example using dualvar in the long-running Long List is Long saga)
• Re: eval to replace die? (Exceptions and Error Handling References)
• std::error_code (cppreference.com, since C++11) - a platform-dependent error code
• std::expected (cppreference.com, since C++23) - an object of std::expected<T,E> holds an expected value of type T, or an unexpected value of type E; it's never valueless
• std::unexpected (cppreference.com, since C++23)
• Expect the expected (youtube) by Andrei Alexandrescu
• std::variant (cppreference.com, since C++17) - a type-safe union; you can avoid exceptions by having a function return, for example, a std::variant<string, error_code> (similar in style to Haskell) - see Stroustrup, A Tour of C++, p 209 (superseded by std::expected?)
• std::optional (cppreference.com, since C++17 - manages an optional contained value, i.e. a value that may or may not be present)

All scalars are already schizophrenic

This has little to do with the values, and more with the operations you are doing. If a value starts with a number, it will be treated as that number when used in numeric operations. And it will issue a warning if it is followed by non-numeric data, as you demonstrated. "0z" is not comparing as "less than zero", it is comparing equal to zero. And the ++ operator has two different functions depending on what type of input it is given.

This is even more weird.. I want to see if the numeric part of a filehandle was the same of what fileno returned.. it would be fun.. but no fileno

The value shown is a GLOB reference, which internally contains the file handle in its IO slot. All references, aside from objects using overloading, numify to their refaddr.

$ perl -le'my $ref = []; print $ref; printf "%s(0x%x)", ref $ref, 0+$ref;'
ARRAY(0x15500a648)
ARRAY(0x15500a648)

<shameless plug>

create your own TripleVal.

Show all entries in the value.

</shameless plug>