This check has always been highly fragile (sorry for the Windows command line quoting):

perl -Mutf8 -e "$x = qq(42); if( 0+$x ) {}; if ($x ^ $x) {print qq(str
+ing\n);}"
[download]

That oneliner outputs nothing thus considers $x not a string even if $x was never "modified". A simple check of a variable can change what "value type" your test considers that variable to contain.

Hi vkhera,

So do I understand correctly that you want to tell the difference between 42 and "42"? That's nontrivial, see How can I test for the representation of an integer? and the links therein, especially the answers to this StackOverflow post. There's also this thread: How to check if a scalar value is numeric or string?, which includes a mention of the ^ trick you're using.

Hope this helps,
-- Hauke D

use strict;
use warnings;

use Inline C => Config =>
 BUILD_NOISY => 1,
 ;

use Inline C => <<'END_C';

int foo(SV * in) {
  if(SvIOK(in) || SvNOK(in)) return 1;
  return 0;
}

END_C

my $num =    42;
my $str =  "42";
my $ref = \$num;
my $nv  = 42.42;
my $dual = "42"; # POK flag set.
if($dual > 0){}  # IOK flag also set 

print foo($num), " ", xor_check($num), "\n";
print foo($str), " ", xor_check($str), "\n";
print foo($ref), " ", xor_check($ref), "\n";
print foo($nv) , " ", xor_check($nv) , "\n";
print foo($dual), " ", xor_check($dual), "\n";

sub xor_check {
  return 0 if($_[0] ^ $_[0]);
  return 1;
}

__END__
Outputs (perl-5.24.0):
1 1
0 0
0 0
1 1
1 1
[download]

use autobox::universal qw(type);

say type("42");  # STRING
say type(42);    # INTEGER
say type(42.0);  # FLOAT 
say type(undef); # UNDEF
[download]

Its better not to do detection, but simply force numification if you're expecting a number, and let warnings issue a warning

#!/usr/bin/perl --
use strict;
use warnings;
use B();
sub SvTYPE (\[$@%&*]) { use B(); ref(B::svref_2object($_[0])) }
{
    my $x = 42; 
    TYPE(\$x);
}
{
    my $x = 42.24;
    TYPE(\$x);
}
{
    my $x = "42.24"; 
    TYPE(\$x);
    $x=$x+0;
    print SvTYPE($x), "\n";
}
{
    my $x = "00042"; 
    TYPE(\$x);
    $x=$x+0;
    print SvTYPE($x), "\n";
}
{
    my $x = "42\x{260E}";
    TYPE(\$x);
}

sub TYPE { 
    no warnings;
    print $_[0],' = ', ${$_[0]},' = ', ref(B::svref_2object($_[0])), "
+\n";
}
__END__
[download]

SCALAR(0xae664c) = 42 = B::IV
SCALAR(0xae637c) = 42.24 = B::NV
SCALAR(0xae633c) = 42.24 = B::PV
B::PVNV
SCALAR(0xae627c) = 00042 = B::PV
B::PVIV
SCALAR(0xae609c) = 42☎ = B::PV

That doesn't help.

Those class names just tell you the type of scalar, but nothing about the value within.

For example, if you get B::IV, all you know is that the scalar contains one of the following:

• Nothing (undef)
• A signed integer
• An unsigned integer
• A reference

For example, if you get B::PVIV, all you know is that the scalar contains one of the following:

• Nothing (undef)
• A signed integer
• An unsigned integer
• A string
• A reference
• A signed integer and a string
• An unsigned integer and a string