This may all be explained in the upcoming A12, but I'm trying to get
Accessors figured out in my head, and I had a few questions and comments.
===== paraphrased from Damian in http://www.nntp.perl.org/group/perl.perl6.language/9576)
it seems very likely that if you write:
class Foo { # version 1
has $.bar_attr is public;
}
then you'll get an automagically created lvalue accessor method that will
allow you to write:
my $foo = Foo.new();
$foo.bar_attr = 1;
and then later define a real C<Foo::bar_attr> method to encapsulate it:
class Foo { # version 2
has $.bar_attr is public;
method bar_attr is rw($rvalue) () {
if exists $rvalue {
croak "Negative value" if $rvalue < 0;
$.bar_attr = $rvalue;
}
return $.bar_attr;
}
}
=====
From Damian's comments I conclude:
There will be one autogenerated accessor, with the same name as the
attribute (not get/set pairs).
It will work correctly in all these cases:
$x = $foo.bar_attr; # read
$foo.bar_attr = $x; # write
$x = $foo.bar_attr = $y; # write then read
My question is about these cases:
$foo.bar_attr += $z # read then write
$foo.bar_attr++;
L<Apocalypse 6/Lvalue subroutines> would seem to apply here because of the
"is rw" trait. It says I will need to return a proxy object in order for
these cases to work right, because I only get to return from the accessor
once, and subsequent writes are performed on the proxy object.
In fact, I think Damian's example above (written long before A6, so not
his fault) would fail to croak if I wrote:
$foo.bar_attr = 12;
$foo.bar_attr -= 100;
According to A6, it should probably be written like this:
method bar_attr() is rw {
return my $bar_proxy is Proxy(
for => $.bar_attr,
STORE => {
croak "Negative value" if $_ < 0;
$.bar_attr = $_;
},
);
}
But if we *always* have to return a proxy object, in case someone uses +=
on our attribute, I can see users yearning for the simplicity of get/set,
even if it is not as syntactically sweet.
I really like the "is Proxy" for tie-ing things, but I keep thinking its a
bit of overkill for accessors. From an easy-things-should-be-easy
perspective, I wouldn't mind at all if $object.attr += 3 magically
arranged to call an accessor twice: once to read, and once to write.
The accessor would have a simple signature:
method bar(?$val) {...}
It is simple to know if the accessor is reading or writing:
method bar(?$val) {
print "Ima reader" if want;
print "Ima writer" if exists $val;
}
But I am asking for magic with that, because $foo.bar is no longer what it
looks like (a method with no arguments). "$foo.bar += 3" is transformed
into "$for.bar($foo.bar() + 3)". I may lose things like the ability to
bind, etc.
A proxy should be able to do anything, it just doesn't do it as simply as
I want. So it occurs to me that it might be possible to implement the one
in terms of the other. To do that I need to explore another area from the
upcoming apocalypse (traits), so forgive my deficient syntax.
I want to get from here
method bar_attr(?$val) is accessor {
$.bar_attr = $val if exists $val;
return $.bar_attr;
}
to here
method bar_attr() is rw {
return my $x is Proxy (
for => $.bar_attr,
FETCH => { $.bar_attr },
STORE => { $.bar_attr = $_ },
);
}
using a break-the-rules trait called accessor.
I'm not sure what method gets called when a trait is applied to something,
so I will assume that APPLY is called with the something it is applied to
as the invocant.
trait accessor {
my $proxy is Proxy;
method APPLY( Code $acc : ) {
# "Proxy" is a trait/role with FETCH and STORE attributes (?)
$proxy.FETCH = { $acc() };
$proxy.STORE = { $acc($^a) };
# Proxy.for is not set, since I do not know what is being
# proxied; I only know how to access it.
# add the rw trait
$acc but= rw;
# wrap the applyee
$acc.wrap( sub (?$val) {
$proxy = $val if exists $val; # so $foo.bar(1) still works
return $proxy;
} );
}
}
I *think* that accomplishes my goal of simple-to-write accessors (for
scalars, at least). Now I only have to change the signature in Damian's
example, and I think it will work for $foo.bar_attr -= 9999999;
method bar_attr(?$rvalue) is accessor {
if exists $rvalue {
croak "Negative value" if $rvalue < 0;
$.bar_attr = $rvalue;
}
return $.bar_attr;
}
Or maybe I'm missing the point completely.... comments? rebuttals?
~ John Williams
