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:

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

    * 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. 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>

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.

POD ERRORS
    Hey! The above document had some coding errors, which are explained
    below:

    Around line 532:
        Non-ASCII character seen before =encoding in 'BurzyĆski'. Assuming
        UTF-8

