#!/usr/bin/perl -l

my $foo = Foo->new(givenName => 'original');
print $foo->givenName;

$foo->givenName(42);
print $foo->givenName;

package Foo;
use Class::MethodMaker
   new_hash_init => 'new',
   get_set       => qw(givenName),
;
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

Or the phenomenally featured Class::MakeMethods.

In Perl5 you would do it something like this:

define givenName {
    my $self = shift;
    $self->{_givenName} = shift if @_;
    return $self->{_givenName};
};
[download]

Umm, define? ;-)

sub givenName { 
    $_[0]->{_givenName} = $_[1] if @_>1;
    $_[0]->{_givenName};
};
[download]

*grin*

Umm, define? ;-)

Fiddlesticks! Fixed now. In my defense I had been playing with Ruby earlier in the day, which use def.

So many languages... so little brain.

I like using Attribute::Property for this.

# Perl 5

use Attribute::Property;

package SomeClass;
sub given_name : Property;
[download]

# Perl 6

class SomeClass {
    has $.given_name is public;
}
[download]

Given a constructor called new, this makes the following code possible:

# Perl 5

my $object = SomeClass->new;

$object->given_name = 5;

print $object->given_name, "\n";
[download]

# Perl 6

my $object = SomeClass.new;

$object.given_name = 5;

print $object.given_name, "\n";
[download]

Compare $object->given_name =~ s/foo/bar/ to its "@_ > 1" equivalent: (my $temp = $object->given_name) =~ s/foo/bar/; $object->given_name($temp);.
Or something simple like $object->given_name++, which using the classic syntax would be $object->given_name($object->given_name + 1). It feels like BASIC to me :)

(Properties created with Attribute::Property do support the classic syntax).

Juerd # { site => 'juerd.nl', plp_site => 'plp.juerd.nl', do_not_use => 'spamtrap' }

sub foo {
    my $self = shift;
    my $old = $self->{'foo'};
    $self->{'foo'} = shift if @_;
    $old;
} #foo
[download]

And of course, many of these accessor/mutator methods are created automatically when they are needed using some AUTOLOAD magic.

Liz

In the alpaca book, I argue that a setter might return one of many possible values:
• The value just being set
• A success/failure boolean
• The previous value
• The value of $self (for chaining)
All have merit, and choosing any one means you don't get the others. Please don't have a religious war here. {grin}

-- Randal L. Schwartz, Perl hacker
Be sure to read my standard disclaimer if this is a reply.

I personally like my mutators/accessors made in such a way, that if you are setting a value, it will return the old value.

I find that this approach is a little strange. It makes sense for a subroutine like select or delete but for a get/set accessor I think the behaviour would be a touch unusual. A set accessor is like an assignment statement, and as such I would expect it to behave similarly to an assignment operator.

Although I admit that often I use the "return $self on set" approach quote a bite as I like the economy of notation that this provides the end user.

And of course, many of these accessor/mutator methods are created automatically when they are needed using some AUTOLOAD magic.

Ive done this as well, but apparently its use should be carefully considered as each time AUTOLOAD creates a new method the method cache is spoiled for _all_ methods, meaning that there could be considerable performance hit from doing it. I've not experimented to see how critical this is, but more than one knowledgable monk has made this assertion and I have little reason to doubt them.


---
demerphq

_{<Elian> And I do take a kind of perverse pleasure in having an OO assembly language...}

...I find that this approach is a little strange. It makes sense for a subroutine like select or delete but for a get/set accessor I think the behaviour would be a touch unusual...

I must say, I don't need it much. But when I do need it, I don't have to think about it. And it's not getting in the way of anything otherwise.

...the method cache is spoiled for _all_ methods, meaning that there could be considerable performance hit from doing it..

Surely that is negligeble if you're calling the same method many times? And if you're not, your program probably doesn't run long. So you won't notice any performance hit.

Not creating a subroutine and keeping it part of the AUTOLOAD routine,. will mean a lot of lookups will have to be done for each method call. Which is certainly a performance hit.

I guess YMMV ;-)

Liz

I personally like my mutators/accessors made in such a way, that if you are setting a value, it will return the old value.

I do that sometimes if I think it would be useful. I usually return $self so $i->can->chain->methods->like->this - but I probably shouldn't start that discussion again :-)

--traveler

You can do it that way, but see lvalue considered harmful... for some reasons why it may be a bad idea.

Jeurd's Attribute::Property is worth investigating if you like the lvalue style. It resolves some of the problems of lvalue subs at the expense of some tied objects behind the scenes.