strict/warnings

Helpful exports

extends

    package MyClass;
    extends 'MyBaseClass';

Supports multiple inheritance, by allowing multiple classes on a single invocation.

with

    with 'ThisClass', 'ThatClass';

has

    has this => ();

NOTE: Class::XSAccessor will be used for simple accessors if it is installed. This can be disabled by setting $Moos::CAN_HAZ_XS to false or by setting the PERL_MOOS_XS_DISABLE to true.

is

Specify which type of attribute accessor to provide. The default is "rw", a read-write accessor. Read-only "ro" accessors are also supported.

    has this => ( is => "ro" );
    has 'this';                   # read-write
    has that => ();               # read-write
    

Unlike Moose, Moos cannot generate differently named getters and setters. If you want your setter named something different (e.g. a private method), then you could do something like:

    has this => ( is => 'ro' );
    sub _set_this { $_[0]{this} = $_[1] }
    

required

Require that a value for the attribute be provided to the constructor or generated during object construction.

    has this => ( required => 1 );
    

lazy

Don't generate defaults during object construction.

    has this => ( builder => '_build_this', lazy => 1 );
    

trigger

A coderef which will be called when the attribute is assigned to via a method call or the constructor. (But not when an attribute is implicitly given a value via a default or builder.) The coderef is called with the instance as the first parameter, the new value as the second parameter, and the old value (if any) as the third parameter.

    has age => ( trigger => sub {
        croak "non-numeric age" unless looks_like_number($_[1]);
    } );
    

Triggers can be used to emulate Moose's type constraints, coercion and weakened reference features, but if you find yourself doing this frequently then you should consider upgrading to Moo or Moose.

handles

Delegated method calls.

    has wheels => (handles => [qw/ roll /]);
    

This accepts a hashref or arrayref, but not the other possibilities offered by Moose.

builder

Specify the method name to generate a default value.

    has this => ( builder => '_build_this' );
    has that => ( builder => 1 );  # accept default name for method
    

default

Specify the sub to generate a default value.

    has this => ( default => sub { 42 } );
    

Moos provides a shortcut for specifying the default. If the number of arguments (after the name) is an odd number, then the first argument is the default. The following forms are valid:

    has a => 42;
    has b => 'string' => (lazy => 1);
    has c => {};
    has d => [1, 2, 3, 4];
    

These all result in creating a Moos "default" argument. If the default is an array or hash reference, a shallow copy is made.

clearer

Creates a clearer method.

    has this => ( clearer => "clear_this" );
    has that => ( clearer => 1 );  # accept default name for method
    

predicate

Creates a predicate method, which can be used to check if the attribute is set or unset.

    has this => ( predicate => "has_this" );
    has that => ( predicate => 1 );  # accept default name for method
    

Class and Object Methods

new

A constructor class method.

    my $object = MyClass->new(this => 'nice', that => 2);
    

BUILD

Custom object construction. If you define BUILD, it is passed the value of the new object during construction. You can modify the object. Any value you return is ignored.

    sub BUILD { my $self = shift; ... }
    

BUILDARGS

Custom constructor argument processing. If you define BUILDARGS, you can control how the constructor's arguments are built into the object hashref.

    sub BUILDARGS { my ($class, @args) = @_; ... }
    

dump

Returns a textual dump of the object.

meta

Returns a Moos::Meta::Class object for the class. This has a very limited subset of Moose::Meta::Class' functionality, including implementations of the following methods: "name", "attribute_metaclass", "add_attribute", "add_method", "superclasses", "linearized_isa", "new_object", "get_all_attributes", "get_attribute" and "find_attribute_by_name".

The attribute introspection methods return Moos::Meta::Attribute objects which provide a very limited subset of Moose::Meta::Attribute's functionality, including implementations of the following methods: "name", "associated_class", "predicate", "clearer", "default", "builder", "trigger", "required", "lazy" and "documentation".

does/DOES

Methods to check whether the classobject performs a particular role. The methods differ in that "does" checks roles only in the MooseMoo/Role::Tiny sense; "DOES" also takes into account UNIVERSAL::DOES.

Roles

    {
        package Local::Class;
        use Moos;
        with "Local::Role";
        ...;
    }

Limitations: Note that Moo and Moose each allow type constraints for attributes; Moos does not. This means that if you compose, say, a Moose::Role into a Moos class, you end up with a strange situation where the accessor methods will enforce type constraints (because they were generated by Moose) but the constructor will not (because it is inherited from Moos::Object).

See also Moos::Role.

Method Modifiers

Development Options

PERL_MOOS_ACCESSOR_CALLS

By setting this environment variable, Moos will warn everytime an accessor method is called.

PERL_MOOS_XXX

By setting the environment variable, Moos will export the XXX debugging keywords.