Role::Tiny(3pm) 					User Contributed Perl Documentation					   Role::Tiny(3pm)

NAME

       Role::Tiny - Roles. Like a nouvelle cuisine portion size slice of Moose.

SYNOPSIS

	package Some::Role;

	use Role::Tiny;

	sub foo { ... }

	sub bar { ... }

	around baz => sub { ... }

	1;

       else where

	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 Moo::Role.

DESCRIPTION

       "Role::Tiny" is a minimalist role composition tool.

ROLE COMPOSITION

       Role composition can be thought of as much more clever and meaningful multiple inheritance.  The basics of this implementation of roles is:

       o If a method is already defined on a class, that method will not be composed in from the role.

       o If a method that the role "requires" to be implemented is not implemented, role application will fail loudly.

       Unlike Class::C3, 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.

IMPORTED SUBROUTINES

   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.

SUBROUTINES

   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

METHODS

   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.

   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.

SEE ALSO

       Role::Tiny is the attribute-less subset of Moo::Role; Moo::Role is a meta-protocol-less subset of the king of role systems, Moose::Role.

       If you don't want method modifiers and do want to be forcibly restricted to a single role application per class, Ovid's Role::Basic exists.
       But Stevan Little (the Moose author) and I don't find the additional restrictions to be amazingly helpful in most cases; Role::Basic's
       choices are more a guide to what you should prefer doing, to our mind, rather than something that needs to be enforced.

AUTHOR

       mst - Matt S. Trout (cpan:MSTROUT) <mst@shadowcat.co.uk>

CONTRIBUTORS

       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. BurzyAaXski (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>

COPYRIGHT

       Copyright (c) 2010-2012 the Role::Tiny "AUTHOR" and "CONTRIBUTORS" as listed above.

LICENSE

       This library is free software and may be distributed under the same terms as perl itself.

perl v5.14.2							    2012-06-19							   Role::Tiny(3pm)