NAME<\/a> autobox \u2212 call methods on native types<\/p>\n use autobox; The autobox pragma allows methods to be called on integers, floats, strings, arrays, hashes, and code references in exactly the same manner as blessed references.<\/p>\n Autoboxing is transparent: values are not blessed into their (user-defined) implementation class (unless the method elects to bestow such a blessing) \u2212 they simply use its methods as though they are.<\/p>\n The classes (packages) into which the native types are boxed are fully configurable. By default, a method invoked on a non-object value is assumed to be defined in a class whose name corresponds to the “ref()” type of that value \u2212 or SCALAR<\/small> if the value is a non-reference.<\/p>\n This mapping can be overridden by passing key\/value pairs to the “use autobox” statement, in which the keys represent native types, and the values their associated classes.<\/p>\n As with regular objects, autoboxed values are passed as the first argument of the specified method. Consequently, given a vanilla “use autobox”:<\/p>\n “Hello, world!”\u2212>upper()<\/p>\n is invoked as:<\/p>\n SCALAR::upper(“hello, world!”)<\/p>\n while:<\/p>\n [ 1 .. 10 ]\u2212>for_each(sub { … })<\/p>\n resolves to:<\/p>\n ARRAY::for_each([ 1 .. 10 ], sub { … })<\/p>\n Values beginning with the array “@” and hash “%” sigils are passed by reference, i.e. under the default bindings:<\/p>\n @array\u2212>join(‘, ‘) are equivalent to:<\/p>\n ARRAY::join(@array, ‘, ‘) Multiple “use autobox” statements can appear in the same scope. These are merged both “horizontally” (i.e. multiple classes can be associated with a particular type) and “vertically” (i.e. multiple classes can be associated with multiple types).<\/p>\n Thus:<\/p>\n use autobox SCALAR => ‘Foo’; \u2212 associates SCALAR<\/small> types with a synthetic class whose @ISA includes both Foo and Bar (in that order).<\/p>\n Likewise:<\/p>\n use autobox SCALAR => ‘Foo’; and<\/p>\n use autobox SCALAR => [ ‘Foo’, ‘Bar’ ]; \u2212 bind SCALAR<\/small> types to the Foo and Bar classes and ARRAY<\/small> types to Baz.<\/p>\n autobox is lexically scoped, and bindings for an outer scope can be extended or countermanded in a nested scope:<\/p>\n { Autoboxing can be turned off entirely by using the “no” syntax:<\/p>\n { \u2212 or can be selectively disabled by passing arguments to the “no autobox” statement:<\/p>\n use autobox; # default bindings Autoboxing is not performed for barewords i.e.<\/p>\n my $foo = Foo\u2212>new();<\/p>\n and:<\/p>\n my $foo = new Foo;<\/p>\n behave as expected.<\/p>\n Methods are called on native types by means of the arrow operator. As with regular objects, the right hand side of the operator can either be a bare method name or a variable containing a method name or subroutine reference. Thus the following are all valid:<\/p>\n sub method1 { … } A native type is only associated with a class if the type => class mapping is supplied in the “use autobox” statement. Thus the following will not work:<\/p>\n use autobox SCALAR => ‘MyScalar’; \u2212 as no class is specified for the ARRAY<\/small> type. Note: the result of calling a method on a native type that is not associated with a class is the usual runtime error message:<\/p>\n Can’t call method “some_array_method” on unblessed reference at …<\/p>\n As a convenience, there is one exception to this rule. If “use autobox” is invoked with no arguments (ignoring the DEBUG<\/small> option) the four main native types are associated with classes of the same name.<\/p>\n Thus:<\/p>\n use autobox;<\/p>\n \u2212 is equivalent to:<\/p>\n use autobox { This facilitates one-liners and prototypes:<\/p>\n use autobox; However, using these default bindings is not recommended as there\u2019s no guarantee that another piece of code won\u2019t trample over the same namespace\/methods.<\/p>\n A mapping from native types to their user-defined classes can be specified by passing a hashref or a list of key\/value pairs to the “use autobox” statement.<\/p>\n The following example shows the range of valid arguments:<\/p>\n use autobox { The INTEGER, FLOAT, NUMBER, STRING, SCALAR, ARRAY, HASH, CODE, UNDEF, DEFAULT<\/small> and UNIVERSAL<\/small> options can take three different types of value:<\/p>\n
SYNOPSIS<\/a>
DESCRIPTION<\/a>
OPTIONS<\/a>
METHODS<\/a>
UNIVERSAL METHODS FOR AUTOBOXED TYPES<\/a>
EXPORTS<\/a>
CAVEATS<\/a>
VERSION<\/a>
SEE ALSO<\/a>
AUTHOR<\/a>
COPYRIGHT AND LICENSE<\/a> <\/p>\n
\nNAME <\/a> <\/h2>\n
SYNOPSIS <\/a> <\/h2>\n
# integers
my $range = 10\u2212>to(1); # [ 10, 9, 8, 7, 6, 5, 4, 3, 2, 1 ]
# floats
my $error = 3.1415927\u2212>minus(22\/7)\u2212>abs();
# strings
my @list = ‘SELECT bodies manpages.csv script_extrae_body.sh script.sh usr FROM foo’\u2212>list();
my $greeting = “Hello, world!”\u2212>upper(); # “HELLO, WORLD!”
$greeting\u2212>for_each(&character_handler);
# arrays and array refs
my $schwartzian = @_\u2212>map(…)\u2212>sort(…)\u2212>map(…);
my $hash = [ ‘SELECT bodies manpages.csv script_extrae_body.sh script.sh usr FROM foo WHERE id IN (?, ?)’, 1, 2 ]\u2212>hash();
# hashes and hash refs
{ alpha => ‘beta’, gamma => ‘vlissides’ }\u2212>for_each(…);
%hash\u2212>keys();
# code refs
my $plus_five = (&add)\u2212>curry()\u2212>(5);
my $minus_three = sub { $_[0] \u2212 $_[1] }\u2212>reverse\u2212>curry\u2212>(3);
# can, isa, VERSION, import and unimport can be accessed via autobox_class
42\u2212>autobox_class\u2212>isa(‘MyNumber’)
say []\u2212>autobox_class\u2212>VERSION<\/p>\nDESCRIPTION <\/a> <\/h2>\n
@{ … }\u2212>length()
%hash\u2212>keys()
%$hash\u2212>values()<\/p>\n
ARRAY::length(@{ … })
HASH::keys(%hash)
HASH::values(%$hash)<\/p>\n
use autobox SCALAR => ‘Bar’;<\/p>\n
use autobox SCALAR => ‘Bar’;
use autobox ARRAY => ‘Baz’;<\/p>\n
use autobox ARRAY => ‘Baz’;<\/p>\n
use autobox; # default bindings: autobox all native types
…
{
# appends ‘MyScalar’ to the @ISA associated with SCALAR types
use autobox SCALAR => ‘MyScalar’;
…
}
# back to the default (no MyScalar)
…
}<\/p>\n
use autobox;
…
no autobox;
…
}<\/p>\n
no autobox qw(SCALAR);
[]\u2212>foo(); # OK: ARRAY::foo([])
“Hello, world!”\u2212>bar(); # runtime error<\/p>\n
my $method2 = ‘some_method’;
my $method3 = sub { … };
my $method4 = &some_method;
” … “\u2212>method1();
[ … ]\u2212>$method2();
{ … }\u2212>$method3();
sub { … }\u2212>$method4();<\/p>\n
@array\u2212>some_array_method();<\/p>\n
SCALAR => ‘SCALAR’,
ARRAY => ‘ARRAY’,
HASH => ‘HASH’,
CODE => ‘CODE’,
}<\/p>\n
sub SCALAR::split { [ split ”, $_[0] ] }
sub ARRAY::length { scalar @{$_[0]} }
print “Hello, world!”\u2212>split\u2212>length();<\/p>\nOPTIONS <\/a> <\/h2>\n
SCALAR => ‘MyScalar’ # class name
ARRAY => ‘MyNamespace::’, # class prefix (ending in ‘::’)
HASH => [ ‘MyHash’, ‘MyNamespace::’ ], # one or more class names and\/or prefixes
CODE => …, # any of the 3 value types above
INTEGER => …, # any of the 3 value types above
FLOAT => …, # any of the 3 value types above
NUMBER => …, # any of the 3 value types above
STRING => …, # any of the 3 value types above
UNDEF => …, # any of the 3 value types above
UNIVERSAL => …, # any of the 3 value types above
DEFAULT => …, # any of the 3 value types above
DEBUG => … # boolean or coderef
}<\/p>\n