This and other RFCs are available on the web at
http://dev.perl.org/rfc/
=head1 TITLE
Objects : Private keys and methods
=head1 VERSION
Maintainer: Damian Conway <[EMAIL PROTECTED]>
Date: 1 September 2000
Mailing List: [EMAIL PROTECTED]
Version: 1
Number: 188
Status: Developing
=head1 ABSTRACT
This RFC proposes a new keyword -- C<private> -- that limits the
accessibility of keys in a hash, and of methods. Its primary use would be to
provide encapsulation of attributes and methods in hash-based objects.
=head1 DESCRIPTION
=head2 Private hash entries
It is proposed that Perl 6 provide a unary function, C<private>, that
restricts hash entries to the current package. The keyword could be applied to
a single hash entry:
private $hash{key};
private $hash{$key};
private $hashref->{key};
or to a hash slice:
private @hash{qw(_name _rank _snum)};
or to a complete hash (either directly, or via a reference):
private %hash;
private { _name => "demo", _rank => "private", _snum => 123 };
private bless { @attrs }, $class;
bless private { @attrs }, $class;
In all cases, a call to C<private> would return its single argument.
The effects of applying C<private> to a single hash entry would be to:
=over 4
=item 1.
mark the entire hash as non-autovivifying (except via future calls to
C<private> -- see below)
=item 2.
mark the particular entry as being restricted to the package in which the
call to C<private> occurs
=back
After a hash has been marked in this way, the specific key would only be
directly accessible in the same package:
package MyClass;
sub new { bless private { secret => 'data' }, $_[0] }
package main;
my $obj = MyClass->new();
print $obj->{secret}; # dies, inaccessible entry
Attempts to autovivify keys of a C<private>-ized hash would also be fatal:
package MyClass;
sub print_me { print $_[0]->{sekret} } # dies, no such entry
package main;
my $obj = MyClass->new();
print $obj->{public}; # dies, can't create entry
Once a hash has been C<private>-ized, the only way to extend its set of
entries is via another call to C<private>:
sub new {
my ($class, %self) = @_;
bless private \%self, $class;
private $self{seed} = rand; # okay
$self{seed} = rand; # dies, can't autovivify
}
Applying C<private> to a hash slice would apply it individually to each
entry in the slice. Applying C<private> to an entire hash (directly, or via
a reference) would apply it to every entry in the hash that is not already
private.
=head3 C<Private> entries and inheritance
Private entries of hashes could be I<indirectly> accessed in packages
that inherit from the entry's package, by qualifying (i.e. prefixing) the
key with the entry's package name. For example:
package Base;
sub new {
my ($class, @data) = @_;
bless private { data => [@data] }, $class;
}
package SortableBase;
use base 'Base';
sub sorted {
my ($self) = @_;
print sort @{ $self->{Base::data} };
}
Note, however, that it would still be a fatal error to attempt to access a
private entry outside its package's hierarchy, even with full qualification:
package main;
my $obj = Base->new(@data);
print $obj->{Base::data}; # dies, not in derived class
Because private entries are only directly acccessible within their own package,
a hash could be given two private entries with the same key, but associated
with different packages. For example:
package Base;
sub new {
my ($class, @data) = @_;
bless private { data => [@data] }, $class;
}
sub data { return $_[0]->{data} }; # Base::data
package Derived;
use base 'Base';
sub new {
my ($class, $derdatum, @basedata) = @_;
my $self = $class->SUPER::new(@basedata);
private $self->{data} = $derdata;
return $self;
}
sub data { return $_[0]->{data} }; # Derived::data
Note that this solves the pernicious "data collision" problem in OO Perl.
=head3 Iteration of C<private>-ized hashes
When a C<private>-ized hash is iterated -- via C<each>, C<keys>, or
C<values> -- the only keys or values returned would be those that are
directly or indirectly accessible within the current package. Furthermore,
iterators that return keys would always return fully qualified keys.
For example:
package Base;
sub new {
my ($class) = @_;
bless private { a=>1, b=>2 }, $class;
}
sub iterate {
my ($obj) = @_;
print join ", ", keys %$obj;
}
package Derived;
use base 'Base';
sub new {
my ($class) = @_;
my $self = $class->SUPER::new();
private $self->{c} = 3;
return $self;
}
sub iterate {
my ($obj) = @_;
print join ", ", keys %$obj;
}
package main;
sub iterate {
my ($obj) = @_;
print join ", ", keys %$obj;
}
my $obj = Derived->new();
Base::iterate($obj); # prints: "Base::a, Base:b"
Derived::iterate($obj); # prints: "Base::a, Base:b, Derived::c"
main::iterate($obj); # prints: ""
This ensures that the encapsulation provided by C<private> isn't accidentally
subverted during iteration.
=head2 Private methods
The C<private> keyword could also be applied to subroutines, to restrict
where they may be called. Access rules similar to those for private hash
entries would apply:
package Base;
sub new { ... }
private sub check { ... }
sub do_check {
my ($self) = @_;
$self->check(); # okay
$self->Base::check(); # okay
check(); # okay
Base::check(); # okay
package Derived;
use base 'Base';
sub do_check {
my ($self) = @_;
$self->check(); # dies, no suitable accessible method
$self->Base::check(); # okay
Base::check($self); # okay
}
package main;
my $obj = Base->new();
$obj->check(); # dies, no suitable accessible method
$obj->Base::check(); # dies, no suitable accessible method
Base::check($obj); # dies, inaccessible subroutine
In other words, declaring a subroutine C<private> causes it to be
ignored during subroutine or method dispatch unless:
=over 4
=item 1.
The call originates in the same package, or
=item 2.
The call originates in a derived package and explicitly qualifies
the subroutine name with the name of its owner package.
=back
Note: an alternative would be to make C<private> a subroutine attribute:
sub check : private { ... }
However, it is felt that the modification C<private> imposes is so
significant that it warrants a prefix modifier. Besides, the C<private>
keyword will be easier to explain and remember if it is consistently
used as a prefix for both hash entries and subroutines.
=head1 MIGRATION
No migration issues.
=head1 IMPLEMENTATION
The Tie::SecureHash module implements much the same idea.
=head1 REFERENCES
Christiansen & Torkington, I<Perl Cookbook>, pp. 470-472.
Conway, I<Object Oriented Perl>, pp. 309-326.
