Tying a blessed object ... you get all the loss in speed for method lookup and all the loss in speed for access. Plus, it ends up being a nightmare to maintain. In my personal tests, which were highly unscientific, I ended up losing about 50% of my speed when I ended up tying my objects. Now, speed isn't everything, but 50% is a lot in my book, for a potentially negative gain in maintainability, all for what seems to be cool factor.

You might want to take a look at lvalued subroutines. Not only do you keep the encapsulation of using methods, but you can treat them like scalars as well.

package Test;

sub new {
    my ($class, $foo, $bar) = @_;
    return bless { 
            foo => $foo
            } => ref($class) || $class;
}

sub foo : lvalue { $_[0]->{foo} }

package main;

my $test = Test->new("foo");
print $test->foo, "\n";

$test->foo = "bar";
print $test->foo, "\n";

$test->foo =~ s/bar/baz/g;
print $test->foo, "\n";

You may be interested in node 288461. There I demonstrate a way to enforce constraints on data accessed by closures on it in lvalue subs. The key was to wedge the constraint test into assignment and friends by tieing the cloistered scalar to a 'Constraint' class.

Don't worry too much about speed; if you have constraints that must be tested, you need correctness and completeness more than speed.

I wrote a benchmark to compare tied scalar with get-and-set processing, and with mutation (passing a code ref to apply to the variable). Results are somewhat disappointing, though not necessarily prohibitive:

          Rate     tie  mutate mutate2 getnset   naked
tie     77.4/s      --    -27%    -36%    -54%    -93%
mutate   107/s     38%      --    -11%    -37%    -91%
mutate2  120/s     55%     13%      --    -29%    -90%
getnset  169/s    118%     58%     40%      --    -86%
naked   1181/s   1426%   1007%    882%    601%      --

naked

is direct access to the variable. This is included for a performance upper bound.

getnset

is a classic two-method-call way of modifying the member

mutate

is a one-method-call way to get, set, or modify (via code ref) the member

mutate2

uses only the get and set forms of the mutate method (to illustrate the overhead of simply having the extra test)

tie

uses a tied scalar whose STORE and FETCH are essentially identical to the get and set methods

The overhead for simply having the encapsulation (the difference between naked and getnset) is about a factor of 6. The overhead for using tie adds another factor of 2+. The more complex the behind-the-scenes machinations of storing and fetching, the less important that overhead will be, but it is significant.

One note about my benchmark program: if you pass it a non-zero argument, it will pass that on to cmpthese. If you don't, it will just sample-run each method to verify that the output is sensible. Use a negative arg for seconds, as positive one for iterations.

#! perl
use strict;

package Ring;
use Carp;
sub TIESCALAR {
  my $class = shift;
  my $arg;
  bless \$arg, $class;
}

sub FETCH {
  my $self = shift;
  confess "wrong type" unless ref $self;
  croak "usage error" if @_;
  return $$self;
}

sub STORE {
  my $self = shift;
  confess "wrong type" unless ref $self;
  my $newval = shift;
  croak "usage error" if @_;
  $$self = $newval % 12;
}

package MyOb;
use Carp;

sub new {
    my $class = shift;
    my $struct = {
        tie     => 0,
        getnset => 0,
        mutate  => 0,
        naked   => 0
    };
    tie $struct->{'tie'}, 'Ring';
    bless $struct, $class;
}

sub get {
  my $self = shift;
  confess "wrong type" unless ref $self;
  croak "usage error" if @_;
  return $self->{'getnset'};
}

sub set {
  my $self = shift;
  confess "wrong type" unless ref $self;
  my $newval = shift;
  croak "usage error" if @_;
  $self->{'getnset'} = $newval % 12;
}

use UNIVERSAL 'isa';
sub mutate {
  my $self = shift;
  confess "wrong type" unless ref $self;
  if (@_) {
    my $set = shift;
    if (isa($set, 'CODE')) {
      $set->() for $self->{'mutate'};
    }
    else { $self->{'mutate'} = $set }
    $self->{'mutate'} %= 12;
  }
  $self->{'mutate'};
}

package Main;
use Benchmark ':all';

my $arg = shift;

my $ob = MyOb->new;

if ($arg) {
  cmpthese($arg, {
    'naked'   => sub { $ob->{'naked'}++, $ob->{'naked'} %= 12 for 1..100 },
    'tie'     => sub { ++$ob->{'tie'} for 1..100 },
    'mutate'  => sub { $ob->mutate(sub{++$_}) for 1..100 },
    'getnset' => sub { $ob->set($ob->get + 1) for 1..100 },
    'mutate2' => sub { $ob->mutate($ob->mutate + 1) for 1..100 },
  });
}
else {
  print 'Naked: ';
  &{sub { $ob->{'naked'}++, $ob->{'naked'} %= 12 for 1..100 }};
  print $ob->{'naked'},"\n";
  print 'Tie: ';
  &{sub { ++$ob->{'tie'} for 1..100 }};
  print $ob->{'tie'}, "\n";
  print 'Mutate: ';
  &{sub { $ob->mutate(sub{++$_}) for 1..100 }};
  print $ob->mutate, "\n";
  print 'GetNSet: ';
  &{sub { $ob->set($ob->get + 1) for 1..100 }};
  print $ob->get, "\n";
  $ob->mutate(0);
  print 'Mutate: ';
  &{sub { $ob->mutate($ob->mutate + 1) for 1..100 }};
  print $ob->mutate, "\n";
}