attr - auto-declare hash attributes for convenient access
const - define compile-time scalar constants
use Alias qw(alias const attr);
alias TEN => $ten, Ten => \$ten, Ten => \&ten,
Ten => \@ten, Ten => \%ten, TeN => \*ten;
{
local @Ten;
my $ten = [1..10];
alias Ten => $ten; # local @Ten
}
const pi => 3.14, ten => 10;
package Foo;
use Alias;
sub new { bless {foo => 1, _bar => [2, 3]}, $_[0] }
sub a_method {
my $s = attr shift;
# $foo, @_bar are now local aliases for
# $_[0]{foo}, @{$_[0]{_bar}} etc.
}
sub b_method {
local $Alias::KeyFilter = "_";
local $Alias::AttrPrefix = "main::";
my $s = attr shift;
# local @::_bar is now available, ($foo, $::foo are not)
}
sub c_method {
local $Alias::KeyFilter = sub { $_ = shift; return (/^_/ ? 1 : 0) };
local $Alias::AttrPrefix = sub {
$_ = shift;
s/^_(.+)$/main::$1/;
return $_
};
my $s = attr shift;
# local @::bar is now available, ($foo, $::foo are not)
}
This module works by putting some values on the symbol table with
user-supplied names. Values that are references will get dereferenced into
their base types. This means that a value of [1,2,3] with a name of ``foo'' will be made available as @foo, not $foo.
The exception to this rule is the default behavior of the attr function, which will not dereference values which are blessed references (aka objects). See $Alias for how to change this default behavior.
callers namespace. If the value supplied is a reference, the alias is created for
the underlying value instead of the reference itself (there is no need to
use this module to alias references--they are automatically ``aliased'' on
assignment). This allows the user to alias most of the basic types.
If the value supplied is a scalar compile-time constant, the aliases become read-only. Any attempt to write to them will fail with a run time error.
Aliases can be dynamically scoped by pre-declaring the target variable as
local. Using attr for this purpose is more convenient, and recommended.
alias %{$_[0]}
but, in addition, also localizes the aliases, and does not dereference
objects. Dereferencing of objects can be forced by setting the Deref
option. See $Alias.
This can be used for convenient access to hash values and hash-based object attributes.
Note that this makes available the semantics of local subroutines and methods. That makes for some nifty possibilities. We could
make truly private methods by putting anonymous subs within an object.
These subs would be available within methods where we use attr, and will not be visible to the outside world as normal methods. We could
forbid recursion in methods by always putting an empty sub in the object
hash with the same key as the method name. This would be useful where a
method has to run code from other modules, but cannot be certain whether
that module will call it back again.
The default behavior is to create aliases for all the entries in the hash, in the callers namespace. This can be controlled by setting a few options. See Configuration Variables for details.
use time, since it reads better for constant declarations. Note that hashes and
arrays cannot be so constrained.
use Alias;
statement. Another typical usage is to localize them in a block so that their values are only effective within that
block.
callers own namespace. For example, setting it to ``main::'' makes use strict 'vars';
somewhat more palatable (since we can refer to the attributes as $::foo, etc., without actually declaring the attributes).
This option can be used as a filter if it is set to a CODE reference, in which case it will be called with the key and the value (whenever the value happens to be a reference), and the boolean return value will determine if that particular reference must be dereferenced.
use Alias qw(alias const attr);
$ten = 10;
alias TEN => $ten, Ten => \$ten, Ten => \&ten,
Ten => \@ten, Ten => \%ten;
alias TeN => \*ten; # same as *TeN = *ten
# aliasing basic types
$ten = 20;
print "$TEN|$Ten|$ten\n"; # should print "20|20|20"
sub ten { print "10\n"; }
@ten = (1..10);
%ten = (a..j);
&Ten; # should print "10"
print @Ten, "|", %Ten, "\n";
# this will fail at run time
const _TEN_ => 10;
eval { $_TEN_ = 20 };
print $@ if $@;
# dynamically scoped aliases
@DYNAMIC = qw(m n o);
{
my $tmp = [ qw(a b c d) ];
local @DYNAMIC;
alias DYNAMIC => $tmp, PERM => $tmp;
$DYNAMIC[2] = 'zzz';
# prints "abzzzd|abzzzd|abzzzd"
print @$tmp, "|", @DYNAMIC, "|", @PERM, "\n";
@DYNAMIC = qw(p q r);
# prints "pqr|pqr|pqr"
print @$tmp, "|", @DYNAMIC, "|", @PERM, "\n";
}
# prints "mno|pqr"
print @DYNAMIC, "|", @PERM, "\n";
# named closures
my($lex) = 'abcd';
$closure = sub { print $lex, "\n" };
alias NAMEDCLOSURE => \&$closure;
NAMEDCLOSURE(); # prints "abcd"
$lex = 'pqrs';
NAMEDCLOSURE(); # prints "pqrs"
# hash/object attributes
package Foo;
use Alias;
sub new {
bless
{ foo => 1,
bar => [2,3],
buz => { a => 4},
privmeth => sub { "private" },
easymeth => sub { die "to recurse or to die, is the question" },
}, $_[0];
}
sub easymeth {
my $s = attr shift; # localizes $foo, @bar, %buz etc with values
eval { $s->easymeth }; # should fail
print $@ if $@;
# prints "1|2|3|a|4|private|"
print join '|', $foo, @bar, %buz, $s->privmeth, "\n";
}
$foo = 6;
@bar = (7,8);
%buz = (b => 9);
Foo->new->easymeth; # this will not recurse endlessly
# prints "6|7|8|b|9|"
print join '|', $foo, @bar, %buz, "\n";
# this should fail at run-time
eval { Foo->new->privmeth };
print $@ if $@;
callers namespace (we can use the AttrPrefix option to specify a different namespace for attr). If that namespace happens to be
localized, the aliases created will be local to that block. attr
localizes the aliases for us.
Remember that references will be available as their dereferenced types.
Aliases cannot be lexical, since, by neccessity, they live on the symbol table.
Lexicals can be aliased. Note that this provides a means of reversing the
action of anonymous type generators \, [] and {}. This allows us to anonymously construct data or code and give it a
symbol-table presence when we choose.
Any occurrence of :: or ' in names will be treated as package qualifiers, and the value will be
interned in that namespace.
Remember that aliases are very much like references, only we don't have to dereference them as often. Which means we won't have to pound on the dollars so much.
We can dynamically make subroutines and named closures with this scheme.
It is possible to alias packages, but that might be construed as abuse.
Using this module will dramatically reduce noise characters in object-oriented perl code.
use strict 'vars'; is not very usable, since we depend so much on the symbol table. You can declare the attributes with use vars to avoid warnings. Setting $Alias::AttrPrefix to ``main::'' is one way to avoid use vars and frustration.
Tied variables cannot be aliased properly, yet.
Copyright (c) 1995-97 Gurusamy Sarathy. All rights reserved. This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.
perl(1)