in reply to How to untie oneself?

Unless you want to mess around with the internals, I don't see how this is possible.

However it is possible to achieve the same effect by having your tie method accept an optional reference which will have the value stored, and then export utility methods that use it. So you might wind up with something like this interface: 

promise(\ my $result_of_long_compute, sub {
  # Long computation here
});

[download]
and then you implement this along the following lines: 
sub promise {
  my ($to_tie, $implement, $opts);
  if (UNIVERSAL::isa($to_tie, 'SCALAR')) {
    tie $$to_tie, Data::Lazy, $implement, $opts;
  }
  elsif (UNIVERSAL::isa($to_tie, 'HASH')) {
    ...
}

[download]
And then document that using the promise() utility function is faster than using the tie interface.

Replies are listed 'Best First'.
Re: Re: How to untie oneself?
by Jenda (Abbot) on Jul 10, 2003 at 22:18 UTC

    Hmmm ... strange. That doesn't seem to work. I tried the additional parameter, I even tried to add a ref to the tied variable to the object later and it did not work. The variable appeared not to be tied within FETCH and stayed tied outside:

    ---------testUntie.pl---------
#!perl
use Data::Lazy;

print "ref=" . \$x . "\n";

tie $x, 'Data::Lazy', sub {sleep 1; 2};
tied($x)->{'var'} = \$x;

print "Tied: " . tied($x) . "\n";
print "\$x=$x\n";
print "Tied: " . tied($x) . "\n";
print "\$x=$x\n";

---------Data/Lazy.pm---------
package Data::Lazy;
#...
sub TIESCALAR {
  my $pack = shift;
  my $self = {};
  $self->{code} = shift;
  $self->{'store'} = $_[0] if $_[0];
  $self->{'type'} = 0;
#  $self->{'var'} = $_[1] if $_[1];
  bless $self => $pack;        # That's it?  Yup!
}
#...
sub FETCH {
  my $self = shift;
  if ($self->{'type'} == 0) { # scalar
   return $self->{value} if exists $self->{value};
   if (ref $self->{code} eq 'CODE') {
         $self->{value} = &{$self->{code}};
   } else {
         $self->{value} = eval $self->{code};
   }
   if ($self->{'store'} == LAZY_STOREVALUE and exists $self->{'var'}) 
+{
       my $var = $self->{'var'};
print "Try to untie $var tied to " . tied($$var) . "\n";
       untie($$var);
       $$var = $self->{value};
       undef $self;
       return $$var;
   } else {
       $self->{value};
   }
  } # ... elsif array and hash
}
#...
1;

    [download]
    and it prints
    ref=SCALAR(0x1a4587c)
Tied: Data::Lazy=HASH(0x15d55d0)
Try to untie SCALAR(0x1a4587c) tied to
$x=2
Tied: Data::Lazy=HASH(0x15d55d0)
$x=2

    [download]
    That is I do have a reference to the right scalar, yet it's not tied ?!?

    I use Perl 5.8 (ActivePerl build 805) under Win2000serverSP4.

    I also tried the same code using Perl 5.6.1 (ActivePerl build 631, same OS) and there it also did not report the reference to be tied, but did succeed to untie it:

    ref=SCALAR(0x1ab2cc0)
Tied: Data::Lazy=HASH(0x1abf078)
Try to untie SCALAR(0x1ab2cc0) tied to
$x=2
Tied:
$x=2

    [download]
    Strange.

    Jenda
    Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live.
       -- Rick Osborne

    Edit by castaway: Closed small tag in signature

[reply]
[d/l]
[select]
      Bizarre.

      I guess that this is tied to the internal implementation of tie. Which I have long thought of as a leaking bandage over a self-inflicted wound.

      I guess the moral is that you shouldn't push tie very far because it isn't very robust. :-(

[reply]

In Section Seekers of Perl Wisdom