I think you will find some
agreement on accessors and mutators that mutators should return the mutated object, and to quote the referenced post "They shall not return the old value, if you wanted to know that you should have asked." (Disclaimer, these are not necessarily my opinions, just other views which may support
Aristotle's proposal).
Personally, I think the chained method calls are more elegant, (e.g. ala File::Find::Rule), but I'll decide later when the need arises if its worthwhile enough to wrap objects in your C::P::MC module :-)
Update: Here's my idea of how a very simplified C::P::MC might work:
#!/usr/bin/perl
package AccessMutate;
# Silly package which returns old values
# when attributes are mutated
sub new {
bless {};
}
sub foo {
my $self = shift;
return $self->{foo} unless @_;
my $old = $self->{foo};
$self->{foo} = shift;
$old;
}
sub bar {
my $self = shift;
return $self->{bar} unless @_;
my $old = $self->{bar};
$self->{bar} = shift;
$old;
}
package C::P::MC;
sub new {
my $class = shift;
my $obj = shift;
bless \shift, $class;
}
# Call the object's method. If called
# in scalar context, returns the proxy
# object. If called in list context, returns
# object, and return value.
# (Update - drawback: assumes
# that the method returns a scalar.., could
# probably be fixed with some wantarray logic)
sub AUTOLOAD {
my $self = shift;
my $obj = $$self;
(my $method = $AUTOLOAD) =~ s/.*:://;
my $ret = $obj->$method(@_);
return $obj, $ret, $self;
}
sub DESTROY { 1 }
package main;
use strict;
use warnings;
# Return AM object
my ($obj1) = C::P::MC
->new(AccessMutate->new)
->foo(3)
->bar(2);
print $obj1->foo,"\n";
print $obj1->bar,"\n";
# Return CPMC object
my $obj2 = C::P::MC
->new(AccessMutate->new)
->foo(3)
->bar(2);
my (undef, $foo) = $obj2->foo;
my (undef, $bar) = $obj2->bar;
print "$foo $bar\n";
