ROLE METHODS

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, namespace::clean can be used to exclude undesired subs from roles.

requires

 requires qw(foo bar);

Declares a list of methods that must be defined to compose role.

with

 with 'Some::Role1';
 with 'Some::Role1', 'Some::Role2';

Composes another role into the current role (or class via Role::Tiny::With).

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

 before foo => sub { ... };

See "before method(s) => sub { ... };" in Class::Method::Modifiers for full documentation.

Note that since you are not required to use method modifiers, Class::Method::Modifiers is lazily loaded and we do not declare it as a dependency. If your Role::Tiny role uses modifiers you must depend on both Class::Method::Modifiers and Role::Tiny.

around

 around foo => sub { ... };

See "around method(s) => sub { ... };" in Class::Method::Modifiers for full documentation.

Note that since you are not required to use method modifiers, Class::Method::Modifiers is lazily loaded and we do not declare it as a dependency. If your Role::Tiny role uses modifiers you must depend on both Class::Method::Modifiers and Role::Tiny.

after

 after foo => sub { ... };

See "after method(s) => sub { ... };" in Class::Method::Modifiers for full documentation.

Note that since you are not required to use method modifiers, Class::Method::Modifiers is lazily loaded and we do not declare it as a dependency. If your Role::Tiny role uses modifiers you must depend on both Class::Method::Modifiers and Role::Tiny.

Strict and Warnings

In addition to importing subroutines, using "Role::Tiny" applies strict and warnings to the caller.

does_role

 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.

make_role

 Role::Tiny->make_role('Some::Role');

Makes a package into a role, but does not export any subs into it.

apply_roles_to_package

 Role::Tiny->apply_roles_to_package(
   'Some::Package', 'Some::Role', 'Some::Other::Role'
 );

Composes role with package. See also Role::Tiny::With.

apply_roles_to_object

 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.

create_class_with_roles

 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.

is_role

 Role::Tiny->is_role('Some::Role1')

Returns true if the given package is a role.