Moose - YAPC::NA 2012

Sawyer X
blogs.perl.org/users/sawyer_x
search.cpan.org/~xsawyerx
metacpan.org/author/XSAWYERX
github.com/xsawyerx/
„The Dancer guy!“
Projects: Dancer, Module::Starter, MetaCPAN::API,
MooseX::Role::Loggable, etc.

Moose
Object system
Metaclass-based
Advanced
Sophisticated
Extensible
Production-ready

… but why Moose?
package Person; package User;

use strict; use Email::Valid;
use warnings; use Moose;
use Moose::Util::TypeConstraints;
use Carp qw( confess );
use DateTime; extends 'Person';
use DateTime::Format::Natural;
subtype 'Email'
    => as 'Str'
sub new {     => where { Email::Valid>address($_) }
    my $class = shift;     => message { "$_ is not a valid email
    my %p = ref $_[0] ? %{ $_[0] } : @_; address" };

    exists $p{name} has email_address => (
        or confess 'name is a required attribute';     is       => 'rw',
    $class>_validate_name( $p{name} );     isa      => 'Email',
    required => 1,
    exists $p{birth_date} );
        or confess 'birth_date is a required attribute';

    $p{birth_date} = $class
>_coerce_birth_date( $p{birth_date} );
    $class>_validate_birth_date( $p{birth_date} );

    $p{shirt_size} = 'l'
        unless exists $p{shirt_size}:

    $class>_validate_shirt_size( $p{shirt_size} );

    return bless %p, $class;
}

sub _validate_name {
    shift;
    my $name = shift;

    local $Carp::CarpLevel = $Carp::CarpLevel + 1;

    defined $name
        or confess 'name must be a string';
}

Writing objects in basic Perl 5
Create a reference (usually to a hash)
Connect it to a package (using „bless“)
Provide subroutines that access the hash keys
Error check the hell out of it

Writing objects in basic Perl 5, e.g.
package Dog;
use strict; use warnings;
sub new {
my $class = shift;
my $self = bless {}, $class;
return $self;
}
1;

Issues
Defining the same new() concept every time
No parameters for new() yet
Will have to do all error-checking manually

Moose
package Dog;

use Moose;

1;

You get
use strict;
use warnings;
new() method
To hell with ponies, you get a moose!
(roll picture of a moose beating a pony in soccer)

Full affordance accessors (attributes)
has name => ( is => 'rw' );
„ro“ is available for read-only attributes
You can manually change setter/getter via writer/reader
Attributes can have defaults
Attributes can have type constraints
Attributes can have traits
Attributes can be lazy, have builders, clearers, predicates...

Type constraints
has name => ( is => 'ro', isa => 'Str' );
Str, Int, Bool, ArrayRef, HashRef, CodeRef, Regex,
Classes
Combine: ArrayRef|HashRef, ArrayRef[Str]
Derivatives (Int is a Num)
Create your own using subtype, available at
Moose::Util::TypeConstraints

Methods
Same as before
sub run {
my $self = shift;
say qq{I make it a habit only to run when
being chased!};
}

Inheritance easy as...
package Punk
use Moose;
extends 'Person';
Multiple inheritance also possible (extends accepts array)
package Child;
use Moose;
extends qw/Father Mother/;

Roles are even better
package Punk;
use Moose;
with qw/Tattoos Piercings Squatter/;

Roles are things you do, instead of things you are.

More hooks than a coat rack!
package User::WinterAware;
use Moose;
extends 'User';
before leaving => sub {
my $self = shift;
$self->cold and $self->take_jacket;
};

package User::Secure;
use Moose;
extends 'User';
around login => sub {
my $orig = shift;
my $self = shift;
$self->security_check and $self->$orig(@_);
};

Before
After
Around
Inner
Augment

Back to attributes...
has set => (
is => 'rw',
isa => 'Set::Object',
default => sub { Set::Object->new },
required => 1,
lazy => 1,
predicate => 'has_set',
clearer => 'clear_set',

Attribute options: default
default => 'kitteh' # string
default => 3 # number
default => sub { {} } # HashRef
default => sub { [] } # ArrayRef
default => sub { Object->new } # an Object

(if you need a more elaborate sub, use builder)

Attribute options: required
required => 1 # required
required => 0 # not required

Attribute options: lazy
lazy => 1 # make it lazy

Class will not create the slot for this attribute unless it
absolutely has to, defined by whether it is accessed at all.

No access? No penalty!
Lazy == good

Attribute options: builder
builder => 'build_it' # subroutine name

sub build_it {
my $self = shift; # not a problem!
return Some::Object->new( $self-
>more_opts );
}

Attribute options: clearer
clearer => 'clear_it' # subroutine name

# you don't need to create the subroutine
sub time_machine {
my $self = shift;
$self->clear_it; # 'it' never happened :)
}

Attribute options: predicate
predicate => 'has_it' # subroutine name

# you don't need to create the subroutine
sub try_to_do_it {
my $self = shift;
$self->has_it && $self->do_it();
}

Attribute options: lazy_build
lazy_build => 1 # <3

# the same as:
lazy => 1,
builder => '_build_it', # private
clearer => 'clear_it',
predicate => 'has_it',

Example: Comican
A hub for various comics strips
Allow you to fetch comic strips
Standard uniformed interface to add more comics
We'll be using:
Roles
Lazy attributes
Overriding attributes options
Attribute predicates

Comican
comic modules Comican::Comic::Dilber
t interface
role
Comican::Comic::PennyArcade

Comican::Comic::xkcd Comican::
Role::Comic

main module
user

Comican.pm

Comican: overall
Comican.pm is the user's interface
It's a hub for Comican::Comic::* modules
They are objects that fetch specific comic strips
They have a common interface
Defined by Comican::Role::Comic

/^M(?:o(?:o|[ou]se)?)?$/
Moose: standart
Mouse: subset, uses XS, faster
(Any::Moose: use Mouse unless Moose already loaded)
Moo: Pure-Perl, subset, blazing fast
Mo: As little as possible (incl. character count)
M: Really as little as possible
Hummus (HuMoose): Incompatible chickpeas paste

Moose - YAPC::NA 2012

Recommended

More Related Content

What's hot (20)

Viewers also liked (12)

Similar to Moose - YAPC::NA 2012 (20)

More from xSawyer (12)

Recently uploaded (20)

Moose - YAPC::NA 2012