Re^2: ref == "REF"

[gaal]

By that logic, you'd expect NUMBER and STRING return values to ref (or even INTEGERR, UNSIGNED, and DOUBLE)!

I don't think it's harder. If you write recursive code to handle deep references, you just find out you have a reference one level deeper. Hey, maybe we should also have a REFREF value, too, and REFREFREF, ...

As for Dumper.xs, I hadn't looked there, because my question was about Perl usage, which XS is not; it uses the perl API and uses SvTYPE directly. *That* bit of code never sees what ref would return on a variable.

[Anonymous Monk]

Not true,

Since print $$reference (when ref $reference is SCALAR) will always output a value. When ref $reference is REF it will output SCALAR(0xXXXXXX).

The particular code I had in mind is:

  $a = "xyz";
  $b = \$a;
  $c = \$b;
  $d = $c;
  while (ref $d eq "REF") { $d = $$d; }
  $, = " & ";
  print ($a, $b, $c, $d, $dd);

If you look at the output then $d will have the same value of $d

What is different if there was no REF type, and you would need to have a reference (for whatever purpose) at the end of the while, then you will need to create a new reference which will not refer to the same scalar as $b:

  $a = "xyz";
  $b = \$a;
  $c = \$b;
  $d = $c;
  while (ref $d eq "SCALAR" or ref $d eq "REF") { $d = $$d; }
  $, = " & ";
  $e = \$d;
  print ($a, $b, $c, $d, $dd, $e);

$dd is ofcourse undefined, and $e refers to the scalar $d, not to $b. Which means you went one step to far in the iteration.

I don't know wheter this is useful or useless since I haven't really needed it yet, but if I need it I sure will be happy to have it. Else that second loop would need some extra code...

[gaal]

I hope I understand you correctly. If so, then wouldn't the expression

ref $x eq 'SCALAR' && ref $$x

suffice as an idiomatic substitute for the current

ref $x eq 'REF'

?

[Anonymous Monk]

Thinking about it some more made me realize that ref $x eq 'REF' can be used more efficiently then ref $x eq 'SCALAR'. (Although not really on the previous code, since the goal was to keep one reference at the end)

If you have ref $x eq 'REF' then you know that the scalar to which $x refers to is yet another reference, so noone stops you from doing $x = $$$x;, which avoids yet another call to the ref function...

[Anonymous Monk]

Yes it would.

But then you are doing two calls to ref instead of one...

But then another question would be, which one would be the most efficient? (assuming the perl-interpreter does not return REF (and doesn't do any check on it))