in reply to Re^2: ref == "REF"
in thread ref == "REF"

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);

[download]

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);

[download]

$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...

Replies are listed 'Best First'.
Re^4: ref == "REF"
by gaal (Parson) on Oct 18, 2004 at 20:39 UTC
    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'

    ?

[reply]
[d/l]
[select]

      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...

[reply]
[d/l]
[select]
      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))

[reply]
        The current behavior would be the more efficient one. But it is also less clean, conceptually, so (I'm come to conclude) it shouldn't belong in the ref builtin.

        This doesn't matter, though. It is a *very simple extension* to add this feature outside core perl. Something along the lines of: 

        use Inline C => << "EO_REFREF";

int
refref(SV* thing) {
    return SvROK(SvRV(thing));
}
EO_REFREF

        [download]
        (This is not anywhere near tested, though :)
[reply]
[d/l]
[select]

In Section Seekers of Perl Wisdom