Role::Tiny - Roles: a nouvelle cuisine portion size slice of Moose
package Some::Role;
use Role::Tiny;
sub foo { ... }
sub bar { ... }
around baz => sub { ... };
1;
elsewhere
package Some::Class;
use Role::Tiny::With;
# bar gets imported, but not foo
with 'Some::Role';
sub foo { ... }
# baz is wrapped in the around modifier by Class::Method::Modifiers
sub baz { ... }
1;
If you wanted attributes as well, look at the Moo::Role manpage.
Role::Tiny is a minimalist role composition tool.
Role composition can be thought of as much more clever and meaningful multiple
inheritance. The basics of this implementation of roles is:
-
If a method is already defined on a class, that method will not be composed in
from the role. A method inherited by a class gets overridden by the role's
method of the same name, though.
-
If a method that the role requires to be implemented is not implemented,
role application will fail loudly.
Unlike the Class::C3 manpage, where the last class inherited from ``wins,'' role
composition is the other way around, where the class wins. If multiple roles
are applied in a single call (single with statement), then if any of their
provided methods clash, an exception is raised unless the class provides
a method since this conflict indicates a potential problem.
All subs created after importing Role::Tiny will be considered methods to be
composed. For example:
package MyRole;
use List::Util qw(min);
sub mysub { }
use Role::Tiny;
use List::Util qw(max);
sub mymethod { }
In this role, max and mymethod will be included when composing MyRole,
and min and mysub will not. For additional control, the namespace::clean manpage
can be used to exclude undesired subs from roles.
requires qw(foo bar);
Declares a list of methods that must be defined to compose role.
with 'Some::Role1';
with 'Some::Role1', 'Some::Role2';
Composes another role into the current role (or class via the Role::Tiny::With manpage).
If you have conflicts and want to resolve them in favour of Some::Role1 you
can instead write:
with 'Some::Role1';
with 'Some::Role2';
If you have conflicts and want to resolve different conflicts in favour of
different roles, please refactor your codebase.
before foo => sub { ... };
See before method(s) = sub { ... }; in the Class::Method::Modifiers manpage> for full
documentation.
Note that since you are not required to use method modifiers,
the Class::Method::Modifiers manpage is lazily loaded and we do not declare it as
a dependency. If your the Role::Tiny manpage role uses modifiers you must depend on
both the Class::Method::Modifiers manpage and the Role::Tiny manpage.
around foo => sub { ... };
See around method(s) = sub { ... }; in the Class::Method::Modifiers manpage> for full
documentation.
Note that since you are not required to use method modifiers,
the Class::Method::Modifiers manpage is lazily loaded and we do not declare it as
a dependency. If your the Role::Tiny manpage role uses modifiers you must depend on
both the Class::Method::Modifiers manpage and the Role::Tiny manpage.
after foo => sub { ... };
See after method(s) = sub { ... }; in the Class::Method::Modifiers manpage> for full
documentation.
Note that since you are not required to use method modifiers,
the Class::Method::Modifiers manpage is lazily loaded and we do not declare it as
a dependency. If your the Role::Tiny manpage role uses modifiers you must depend on
both the Class::Method::Modifiers manpage and the Role::Tiny manpage.
In addition to importing subroutines, using Role::Tiny applies strict and
warnings to the caller.
if (Role::Tiny::does_role($foo, 'Some::Role')) {
...
}
Returns true if class has been composed with role.
This subroutine is also installed as ->does on any class a Role::Tiny is
composed into unless that class already has an ->does method, so
if ($foo->does('Some::Role')) {
...
}
will work for classes but to test a role, one must use ::does_role directly.
Additionally, Role::Tiny will override the standard Perl DOES method
for your class. However, if any class in your class' inheritance
hierarchy provides DOES, then Role::Tiny will not override it.
Role::Tiny->make_role('Some::Role');
Makes a package into a role, but does not export any subs into it.
Role::Tiny->apply_roles_to_package(
'Some::Package', 'Some::Role', 'Some::Other::Role'
);
Composes role with package. See also the Role::Tiny::With manpage.
Role::Tiny->apply_roles_to_object($foo, qw(Some::Role1 Some::Role2));
Composes roles in order into object directly. Object is reblessed into the
resulting class. Note that the object's methods get overridden by the role's
ones with the same names.
Role::Tiny->create_class_with_roles('Some::Base', qw(Some::Role1 Some::Role2));
Creates a new class based on base, with the roles composed into it in order.
New class is returned.
Role::Tiny->is_role('Some::Role1')
Returns true if the given package is a role.
the Role::Tiny manpage is the attribute-less subset of the Moo::Role manpage; the Moo::Role manpage is
a meta-protocol-less subset of the king of role systems, the Moose::Role manpage.
Ovid's the Role::Basic manpage provides roles with a similar scope, but without method
modifiers, and having some extra usage restrictions.
mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>
dg - David Leadbeater (cpan:DGL) <dgl@dgl.cx>
frew - Arthur Axel ``fREW'' Schmidt (cpan:FREW) <frioux@gmail.com>
hobbs - Andrew Rodland (cpan:ARODLAND) <arodland@cpan.org>
jnap - John Napiorkowski (cpan:JJNAPIORK) <jjn1056@yahoo.com>
ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <ribasushi@cpan.org>
chip - Chip Salzenberg (cpan:CHIPS) <chip@pobox.com>
ajgb - Alex J. G. Burzyński (cpan:AJGB) <ajgb@cpan.org>
doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>
perigrin - Chris Prather (cpan:PERIGRIN) <chris@prather.org>
Mithaldu - Christian Walde (cpan:MITHALDU) <walde.christian@googlemail.com>
ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <ilmari@ilmari.org>
tobyink - Toby Inkster (cpan:TOBYINK) <tobyink@cpan.org>
haarg - Graham Knop (cpan:HAARG) <haarg@haarg.org>
Copyright (c) 2010-2012 the Role::Tiny AUTHOR and CONTRIBUTORS
as listed above.
This library is free software and may be distributed under the same terms
as perl itself.
|