tied($var)->print_method;
[download]

To elaborate on this, what tie accomplishes is to make Perl pretend that a reference object is something else. That is, it acts here as if $var is a simple scalar, not a reference object. (It's probably easier to see that this must be the case when tieing an array or a hash.)

A tied scalar shadows an object whose class provides methods for creation, assignment and destruction. The tied scalar behaves like a scalar, so you can neither bless it into a package, nor call methods on it (would need to be blessed, first).

You are pretty out of luck if you want to use the same thingy as a scalar and an object at the same time. Your FETCH would need to know what the fetch is for - not just void/scalar/list context, but look ahead in the opstack to see whether the result it is about to return is for a method deref. I'm sure that can be done somehow (TheDamian, would you like to? ;-), but it probably would involve too much magic...

Use the object returned by tie to do method calls:

use Link;

my $var_o = tie my $var,"Link","http://somesite.com";
$var = "http://anothersite.com";
$var_o->print_method;
print $var;
[download]

Or what Arunbear said.

I always thought of tied hashes as poor man's objects. If I had to support this code I would rather the code written as an perl object than an implement via tie.

package XML::Trivial::Element;
use Scalar::Util 'weaken';
use strict;
use warnings;

sub new {
    my ($class, $aref, $nsstack) = @_;
    tie my %h, $class, $aref || [], $nsstack;
    my $self =  bless \%h, $class;
    my %ehns;
    my $key;
    my $s = tied(%$self);
    foreach (@{$s->{ea}}) {
    tied(%$_)->{parent} = $self;
    weaken(tied(%$_)->{parent});#because it is circular ref
    $key = $_->ns(undef).'*'.$_->ln();
    $ehns{$key} = $_ unless exists $ehns{$key};
    }
    $s->{ehns} = \%ehns;
    return $self;
}

sub TIEHASH {
    my ($class, $a, $nsstack) = @_;
    #$a is arrayref like [name, atts, type1, data1, type2, data2, ...]
    my @ea; my %eh;#elements
    my @ta;        #texts
    my @ca;        #cdatas
    my @pa; my %ph;#process instructions
    my @na;        #notes
    my $firstkey;
    my $lastkey;
    my %next;
    my %nh;        #hash of namespaces in scope
    foreach (@$nsstack) {
    while (my ($name, $value) = each %$_) {
        $nh{$name} = $value;
    }
    }
    for (my $i = 0; $i < @$a; $i += 2) {
#too much code here
    }
    return bless {a=>$a,
          ea=>\@ea, eh=>\%eh,
          ta=>\@ta,
          ca=>\@ca,
          pa=>\@pa, ph=>\%ph,
          na=>\@na,
          nh=>\%nh,
          parent=>undef,
          firstkey=>$firstkey,
          next=>\%next
         }, $class;
}

sub FETCH {
    my ($self, $key) = @_;
    $key =~ /^\d+$/ and return $$self{ea}[$key];
    $key =~ /\*/ and return $$self{ehns}{$key};
    return $$self{eh}{$key};
}

sub EXISTS {
    my ($self, $key) = @_;
    $key =~ /\*/ and return exists $$self{ehns}{$key};
    return exists $$self{eh}{$key};
}

sub FIRSTKEY {
    return $$_[0]{firstkey};
}

sub NEXTKEY {
    return $$_[0]{next}{$$_[1]};
}

sub SCALAR {
    return $$_[0]{a}[0];
}

#this is object method
sub p { #parent
    my ($self) = @_;
    return tied(%$self)->{parent};
}
[download]

In your case it (yet) seems sufficient to bless a scalar ref instead of a hash ref. So you can fetch and store your link with $$ dereferencing.

Of course this doesn't scale well when your object needs more data...

Then lvalue mutators maybe a handy alternative... but to validate the stored links you need again a tie on the data, see Re: A tale about accessors, lvalues and ties

#!/usr/bin/perl

use strict;
use warnings;
$\="\n";

{
    package LinkClass;

    sub new {
    my $scalar="link";
    my $self=\$scalar;
    bless $self;
    return $self;
    }

    sub print {print ${$_[0]}}

    sub url :lvalue { ${$_[0]} }
}

my $obj=LinkClass->new();

$obj->print();

$$obj="link2";
$obj->print();


$obj->url="link3";
$obj->print();

__END__
link
link2
link3
[download]

a completely other approach maybe using a wrapper write(), which calls tied($var)->print_method; like Arunbear suggested.

write($var);
[download]