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) <[email protected]>

CONTRIBUTORS
   dg - David Leadbeater (cpan:DGL) <[email protected]>

   frew - Arthur Axel "fREW" Schmidt (cpan:FREW) <[email protected]>

   hobbs - Andrew Rodland (cpan:ARODLAND) <[email protected]>

   jnap - John Napiorkowski (cpan:JJNAPIORK) <[email protected]>

   ribasushi - Peter Rabbitson (cpan:RIBASUSHI) <[email protected]>

   chip - Chip Salzenberg (cpan:CHIPS) <[email protected]>

   ajgb - Alex J. G. Burzyński (cpan:AJGB) <[email protected]>

   doy - Jesse Luehrs (cpan:DOY) <doy at tozt dot net>

   perigrin - Chris Prather (cpan:PERIGRIN) <[email protected]>

   Mithaldu - Christian Walde (cpan:MITHALDU)
   <[email protected]>

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.

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.