NAME<\/a> Moose::Cookbook::Roles::Comparable_CodeReuse \u2212 Using roles for code reuse<\/p>\n version 2.2014<\/p>\n package Eq; Roles have two primary purposes: as interfaces, and as a means of code reuse. This recipe demonstrates the latter, with roles that define comparison and display code for objects.<\/p>\n Let\u2019s start with “Eq”. First, note that we\u2019ve replaced “use Moose” with “use Moose::Role”. We also have a new sugar function, “requires”:<\/p>\n requires ‘equal_to’;<\/p>\n This says that any class which consumes this role must provide an “equal_to” method. It can provide this method directly, or by consuming some other role.<\/p>\n The “Eq” role defines its “not_equal_to” method in terms of the required “equal_to” method. This lets us minimize the methods that consuming classes must provide.<\/p>\n The next role, “Comparable”, builds on the “Eq” role. We include “Eq” in “Comparable” using “with”, another new sugar function:<\/p>\n with ‘Eq’;<\/p>\n The “with” function takes a list of roles to consume. In our example, the “Comparable” role provides the “equal_to” method required by “Eq”. However, it could opt not to, in which case a class that consumed “Comparable” would have to provide its own “equal_to”. In other words, a role can consume another role without<\/i> providing any required methods.<\/p>\n The “Comparable” role requires a method, “compare”:<\/p>\n requires ‘compare’;<\/p>\n The “Comparable” role also provides a number of other methods, all of which ultimately rely on “compare”.<\/p>\n sub equal_to { Finally, we define the “Printable” role. This role exists solely to provide an interface. It has no methods, just a list of required methods. In this case, it just requires a “to_string” method.<\/p>\n An interface role is useful because it defines both a method and a name<\/i>. We know that any class which does this role has a “to_string” method, but we can also assume that this method has the semantics we want. Presumably, in real code we would define those semantics in the documentation for the “Printable” role. (1)<\/p>\n Finally, we have the “US::Currency” class which consumes both the “Comparable” and “Printable” roles.<\/p>\n with ‘Comparable’, ‘Printable’;<\/p>\n It also defines a regular Moose attribute, “amount”:<\/p>\n has ‘amount’ => ( is => ‘rw’, isa => ‘Num’, default => 0 );<\/p>\n Finally we see the implementation of the methods required by our roles. We have a “compare” method:<\/p>\n sub compare { By consuming the “Comparable” role and defining this method, we gain the following methods for free: “equal_to”, “greater_than”, “less_than”, “greater_than_or_equal_to” and “less_than_or_equal_to”.<\/p>\n Then we have our “to_string” method:<\/p>\n sub to_string { Roles can be very powerful. They are a great way of encapsulating reusable behavior, as well as communicating (semantic and interface) information about the methods our classes provide.<\/p>\n
VERSION<\/a>
SYNOPSIS<\/a>
DESCRIPTION<\/a>
CONCLUSION<\/a>
FOOTNOTES<\/a>
AUTHORS<\/a>
COPYRIGHT AND LICENSE<\/a> <\/p>\n
\nNAME <\/a> <\/h2>\n
VERSION <\/a> <\/h2>\n
SYNOPSIS <\/a> <\/h2>\n
use Moose::Role;
requires ‘equal_to’;
sub not_equal_to {
my ( $self, $other ) = @_;
not $self\u2212>equal_to($other);
}
package Comparable;
use Moose::Role;
with ‘Eq’;
requires ‘compare’;
sub equal_to {
my ( $self, $other ) = @_;
$self\u2212>compare($other) == 0;
}
sub greater_than {
my ( $self, $other ) = @_;
$self\u2212>compare($other) == 1;
}
sub less_than {
my ( $self, $other ) = @_;
$self\u2212>compare($other) == \u22121;
}
sub greater_than_or_equal_to {
my ( $self, $other ) = @_;
$self\u2212>greater_than($other) || $self\u2212>equal_to($other);
}
sub less_than_or_equal_to {
my ( $self, $other ) = @_;
$self\u2212>less_than($other) || $self\u2212>equal_to($other);
}
package Printable;
use Moose::Role;
requires ‘to_string’;
package US::Currency;
use Moose;
with ‘Comparable’, ‘Printable’;
has ‘amount’ => ( is => ‘rw’, isa => ‘Num’, default => 0 );
sub compare {
my ( $self, $other ) = @_;
$self\u2212>amount <=> $other\u2212>amount;
}
sub to_string {
my $self = shift;
sprintf ‘$%0.2f USD’ => $self\u2212>amount;
}<\/p>\nDESCRIPTION <\/a> <\/h2>\n
my ( $self, $other ) = @_;
$self\u2212>compare($other) == 0;
}
sub greater_than {
my ( $self, $other ) = @_;
$self\u2212>compare($other) == 1;
}
sub less_than {
my ( $self, $other ) = @_;
$self\u2212>compare($other) == \u22121;
}
sub greater_than_or_equal_to {
my ( $self, $other ) = @_;
$self\u2212>greater_than($other) || $self\u2212>equal_to($other);
}
sub less_than_or_equal_to {
my ( $self, $other ) = @_;
$self\u2212>less_than($other) || $self\u2212>equal_to($other);
}<\/p>\n
my ( $self, $other ) = @_;
$self\u2212>amount <=> $other\u2212>amount;
}<\/p>\n
my $self = shift;
sprintf ‘$%0.2f USD’ => $self\u2212>amount;
}<\/p>\nCONCLUSION <\/a> <\/h2>\n
FOOTNOTES <\/a> <\/h2>\n
| <\/td>\n | \n (1)<\/p>\n<\/td>\n | <\/td>\n | \n Consider two classes, “Runner” and “Process”, both of which define a “run” method. If we just require that an object implements a “run” method, we still aren\u2019t saying anything about what that method actually does<\/i>. If we require an object that implements the “Executable” role, we\u2019re saying something about semantics.<\/p>\n<\/td>\n<\/tr>\n<\/table>\n \u2022<\/p>\n<\/td>\n Stevan Little \u2022<\/p>\n<\/td>\n Dave Rolsky \u2022<\/p>\n<\/td>\n Jesse Luehrs \u2022<\/p>\n<\/td>\n Shawn M Moore \u2022<\/p>\n<\/td>\n \u00d7\u00d7\u00d7\u00d7 \u00d7\u00a7\u00d7\u00d7\u2019\u00d7\u00d7 (Yuval Kogman) \u2022<\/p>\n<\/td>\n Karen Etheridge \u2022<\/p>\n<\/td>\n Florian Ragwitz \u2022<\/p>\n<\/td>\n Hans Dieter Pearcey \u2022<\/p>\n<\/td>\n |