Linux cli command Role_Tinypm

➡ A Linux man page (short for manual page) is a form of software documentation found on Linux and Unix-like operating systems. This man-page explains the command Role_Tinypm and provides detailed information about the command Role_Tinypm, system calls, library functions, and other aspects of the system, including usage, options, and examples of _. You can access this man page by typing man followed by the Role_Tinypm.

  5 minute read  

NAME 🖥️ Role_Tinypm 🖥️

Roles: a nouvelle cuisine portion size slice of Moose

SYNOPSIS

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

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.

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.

Strict and Warnings

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

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.

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.

METHODS

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.

CAVEATS

  • On perl 5.8.8 and earlier, applying a role to an object won’t apply any overloads from the role to other copies of the object.

  • On perl 5.16 and earlier, applying a role to a class won’t apply any overloads from the role to any existing instances of the class.

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.

Ovid’s Role::Basic provides roles with a similar scope, but without method modifiers, and having some extra usage restrictions.

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]>

ilmari - Dagfinn Ilmari Mannsåker (cpan:ILMARI) <[email protected]>

tobyink - Toby Inkster (cpan:TOBYINK) <[email protected]>

haarg - Graham Knop (cpan:HAARG) <[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.

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░

  █║▌│║█║▌★ KALI ★ PARROT ★ DEBIAN 🔴 PENTESTING ★ HACKING ★ █║▌│║█║▌

              ██╗ ██╗ ██████╗  ██████╗ ██╗  ██╗███████╗██████╗
             ████████╗██╔══██╗██╔═══██╗╚██╗██╔╝██╔════╝██╔══██╗
             ╚██╔═██╔╝██║  ██║██║   ██║ ╚███╔╝ █████╗  ██║  ██║
             ████████╗██║  ██║██║   ██║ ██╔██╗ ██╔══╝  ██║  ██║
             ╚██╔═██╔╝██████╔╝╚██████╔╝██╔╝ ██╗███████╗██████╔╝
              ╚═╝ ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═════╝

               █║▌│║█║▌ WITH COMMANDLINE-KUNGFU POWER █║▌│║█║▌

░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░