Moose

Delegations

Alternatively, you could utilize Moose's delegation feature when you set up the fired_dt attribute, like this:

has 'fired_dt' => ( 
        is => 'rw', 
        isa => 'DateTime',
        handles => {
                last_fired => 'datetime'
        }
);

This will set up another accessor method named last_fired and map it to the datetime method of the attribute. This makes the invocations of $self->last_fired and $self->fired_dt->datetime equivalent. This is worthwhile because it allows you to keep your API simpler.

Types

Moose provides its own type system for enforcing constraints on the value to which an attribute can be set. As I mentioned earlier, type constraints are set with the isa attribute option.

Moose provides a built-in hierarchy of named types for general-purpose use. For example, Int is a subtype of Num, and Num is a subtype of Str. The value 'foo' would pass Str but not Num or Int; 3.4 would pass Str and Num but not Int, and 7 would pass all of Str, Num and Int.

There also are certain built-in types that can be "parameterized", such as ArrayRef (a reference to an array). This lets you not only require an attribute to contain an ArrayRef, but also set type constraints on the values that ArrayRef can contain. For example, setting isa => 'ArrayRef[Int]' requires an ArrayRef of Ints. These can be nested multiple levels deep, such as 'ArrayRef[HashRef[Str]]' and so on.

Another special parameterized type is Maybe, which allows a value to be undef. For example, 'Maybe[Num]' means the value is either undef or a Num.

You also can use type "unions". For example, 'Bool | Ref' means either Bool or Ref.

If the built-in types aren't sufficient for your needs, you can define your own subtypes to do any kind of custom validation you want. The Moose::Util::TypeConstraints documentation provides details on creating subtypes, as well as a complete listing of the built-in types that are available (see Resources).

Finally, instead of specifying the name of a defined type, you can specify a class name, which will require an object of that class type (such as in our DateTime attribute example). All of these concepts can be intermixed for maximum flexibility. So, for example, if you set isa => 'ArrayRef[MyApp::Rifle]', it would require an ArrayRef of MyApp::Rifle objects.

Inheritance

Subclassing is relatively painless in Moose. Use the extends function to make a class a subclass of another. The subclass inherits all the parent's methods and attributes, and then you can define new ones or override existing ones simply by defining them again.

Moose also provides helpful attribute inheritance sugar that allows you to inherit an attribute from the parent, but override specific options in the subclass. To tell Moose to do this, prepend the attribute name with a plus sign (+) in a "has" declaration in the subclass. (Note: attribute options related to accessor method names cannot be changed using this technique.)

For example, you could create a new class named MyApp::AutomaticRifle that inherits from the MyApp::Rifle class from the previous example:

<![CDATA[
package MyApp::AutomaticRifle;
use Moose;
extends 'MyApp::Rifle';

has '+rounds' => ( default => 50 );
has 'last_burst_num' => ( is => 'rw', isa => 'Int' );

sub burst_fire {
        my ($self, $num) = @_;
	
        $self->last_burst_num($num);

        for (my $i=0; $i<$num; $i++) {
                $self->fire;
        }
}

1;
]]>

Here, MyApp::AutomaticRifle can do everything MyApp::Rifle can do, but it also can "burst_fire". Also, the default of the rounds attribute has been changed to 50 in AutomaticRifle, but the rest of the options for the rounds attribute still are inherited from the parent Rifle class.

You might use MyApp::AutomaticRifle like this:

use strict;
use MyApp::AutomaticRifle;

my $rifle = MyApp::AutomaticRifle->new;
print "There are " . $rifle->rounds . " rounds in the rifle\n";
$rifle->burst_fire(35);
print "Now there are " . $rifle->rounds . " rounds in the rifle\n";

package MyApp::FireAll;
use strict;
use Moose::Role;

requires 'fire', 'rounds';

sub fire_all {
        my $self = shift;
        $self->fire while($self->rounds > 0);
}

1;

with 'MyApp::FireAll';