Introduction To Moose

Introduction to Moose
Italian Perl Workshop 2009
Mike Whitaker - BBC / EnlightenedPerl.org

About me

• BBC iPlayer team

About me

• ex-Yahoo Europe (News team)

About me

• ex-CricInfo.com

About me

• ex-CricInfo.com
• Board member of EnlightenedPerl.org

Why Moose?

• For that, we need a bit of history:

In the Beginning...
• ...there was Perl 5

In the Beginning...
• DIY OO

In the Beginning...
• DIY OO
• perldoc perltoot

In the Beginning...
• DIY OO
• perldoc perltoot

package Foo;

sub new {
my $self = {};
return bless $self;
}

In the Beginning...
package Foo;

• ...there was Perl 5 sub new {
my $self = {};

• DIY OO }
return bless $self;

• perldoc perltoot sub bar {
my $self = shift;
my $val = shift;
package Foo; if (deﬁned $val) {
$self->{bar} = $val;
sub new { }
my $self = {}; else {
return bless $self; return $self->{bar};
} }
}

Perl 5 Native OO

• A bit of a hack

Perl 5 Native OO

• A bit of a hack
• Not really a ﬁrst-class part of the language

Perl 5 Native OO

• A bit of a hack
• Not really a ﬁrst-class part of the language
• Have to roll your own

So...
People started writing classes to make it
easier....

Class::Accessor::Classy Class::Accessor
Object::InsideOut ﬁelds
Hash::FieldHash
Badger::Class Rubyish
OP Object::Declare
Class::Maker UR Class::Gomor
Object::Tiny::XS Class::XSAccessor
Class::Framework
Class::Accessor::Fast Class::Simple
Rose::Object MOP::MOP Coat
Object::InsideOut Class::STD
Class::Object
Class::Base Class::ArrayObjects
Spiffy
Class::Accessor::Grouped Class::Frame
Object::Accessor Object::Tiny Object::Simple
Class::Generate Class::Builder accessors
Fukurama::Class Class::Deﬁne
Abstract::Meta::Class

What is Moose?
• (Post)modern Perl OO framework

What is Moose?
• Deals with the overhead of implementing
OO, allows you to get on with coding

What is Moose?
• Meta-object implementation - allows you to
introspect your classes and objects

What is Moose?
• Meta-object implementation - allows you to
introspect your classes and objects
• Already used in production software

My First Class
package Person;
use Moose;

has name => (
is => 'rw',
);

no Moose;

Using the class
use Person;
my $person = Person->new();

$person->name('Mike');

print $person->name();
> Mike

Adding a method
package Person;
use Moose;

has name => ( is => 'rw' );

sub introduce {
print "I'm " . $self->name;
}

Using it
use Person;


$person->introduce();
> I'm Mike

Read-only attributes
package Person;
use Moose;

has name => ( is => 'ro' );

sub introduce {
print "I'm " . $self->name;
}

Read-only attributes (2)

use Person;

# boom!

Read-only attributes (3)

use Person;
my $person = Person->new(
{ name => 'Mike' },
);

# no boom today!

Changing defaults
has 'name' => (
isa => 'Str',
reader => 'get_name',
writer => 'set_name',
init_arg => 'name',
required => 1,
);

Types
package Person;
use Moose;

has name => (
is => 'rw',
isa => 'Str',
);

Types (2)
use Person;

# shiny!

$person->name( [] );
# boom!
# Not a Str

Types (3)
package Person;
use Moose;

has name => ( is => 'rw', isa => 'Str' );

has dob => (
is => 'rw',
isa => 'DateTime',
);

Types (4)
use Person;
my $person = Person->new(
{ name => 'Mike' }
);
my $dob = DateTime->new (
year => 1963, month => 8, day => 5,
);
$person->dob($dob);
print $person->dob->year;
> 1963

Subclassing
package Student;
use Moose;
extends qw/Person/;

has overdraft => (
isa => 'Bool',
is => 'rw',
);

Compound Types
package Student;
use Moose;
extends qw/Person/;

has classes => (
isa => 'HashRef[Str]',
is => 'rw',
);

Required attributes
package Student;
use Moose;
extends qw/Person/;
# ...
has course => (
isa => 'Str',
is => 'ro',
required => 1,
);

Setting defaults
package Student;
use Moose;

has 'overdraft' => (
isa => 'Bool',
default => 1,
);

But, what if...

package BankAccount;

sub balance {
# yadda yadda
}

And then...
package Student;
use Moose;
extends qw/Person/;

has 'account' => (
isa => 'BankAccount',
is => 'rw',
required => 1,
);

Lazy default
isa => 'Bool',
is => 'ro',
lazy => 1,
default => sub {
shift->account->balance < 0;
}
);

Lazy builder
isa => 'Bool',
is => 'ro',
lazy_build => 1,
init_arg => undef,
);
sub _build_overdraft {
return shift->account->balance < 0;
}

Method modiﬁers
package Student;
# yadda yadda

after 'introduce' => sub {
my $self = shift;
print ', studying ' . $self->course;
}

Using it
use Student;
my $person = Student->new(
name => 'Mike',
course => 'Computer Science',
);

> I'm Mike, studying Computer Science

Method modiﬁers (2)
package Student;
# yadda yadda

around 'introduce' => sub {
my ($next, $self, @args) = @_;
print "Hi, ";
$self->$next(@args);
print ', studying ' . $self->course;
}

Using around
use Student;
name => 'Mike',
course => 'Computer Science',
);

> Hi, I'm Mike, studying Computer Science

Roles
• Code fragments that deﬁne and provide a
small, reusable behaviour

Roles
• Not inherited - methods become part of
consuming class

Roles
consuming class
• can be overriden by comsuming class

Roles
consuming class
• can be overriden by comsuming class
• like MI but better!

Example role
package Age;
use Moose::Role;
has dob => (
isa => 'DateTime', is =>'ro'
);
sub age {
return DateTime->now
->subtract( shift->dob() )
->years;
}

Using a role
package Person;
use Moose;
with qw/Age/;
has name => ( isa => 'Str', is => 'ro');

sub introduce {
print "I'm " . $self->name .
', age ' . $self->age;
}

Using a role (2)
use Student;
name => 'Mike',
dob => ... # yadda yadda
course => 'CS',
);

> Hi, I'm Mike, age 45, studying CS

What we'd really like
use Student;
name => 'Mike',
dob => '05-08-1963',
course => 'CS',
);

Redeﬁne our attr...
package Age;
use Moose::Role;
has dob => (
isa => 'DateStr',
is =>'ro',
);

Types to the rescue

use Moose::Util::TypeConstraints;

subtype 'DateStr'
=> as 'Str'
=> where {
/^dd-dd-dddd$/
};

Types to the rescue (2)
use Moose::Util::TypeConstraints;
class_type 'DateTime';

coerce 'DateTime' => from 'Str'
=> via {
my ($d, $m, $y) = split /-/, $_;
return DateTime->new(
year => $y, month => $m, day => $d
);
};

And then...
package Age;
use Moose::Role;
has dob => (
isa => 'DateTime',
is =>'ro',
coerce => 1, # very important!
);

Et voila...
use Student;
name => 'Mike',
dob => '05-08-1963',
course => 'CS',
);

print $person->age();
> 45

Roles as interfaces
package Earnings;
use Moose::Role;

requires qw/annual_income/;

sub monthly_income {
return shift->annual_income / 12;
}

Roles as interfaces (2)
package Person;
with qw/Earnings/;

package Student;
extends qw/Person/;

sub annual_income {
my $self = shift;
return $self->grant_amount;
}

Role gotchas

• Roles cannot use extends

Role gotchas

• requires only works with actual methods :(

Role gotchas

• for now, at least

Role gotchas

• for now, at least
• watch out for method and attribute
conﬂicts

Method Delegation
package Degree;
use Moose;
use Moose::Utils::TypeConstraints;
enum 'Grade' => qw/I IIi IIii III/;

has 'grade' => ( isa => 'Grade' );
has 'awarded' => (
isa => 'DateTime',
coerce => 1,
);

Method Delegation (2)
package Graduate;
use Moose;
extends qw/Student/;

has 'degree' => (
isa => 'Degree',
is => 'rw',
);

my $g = Graduate->new(name => 'Mike');
my $d = Degree->new(
awarded => '06-06-1985',
grade => 'IIii',
);
$g->degree($d);

print $g->degree->awarded->year;
> 1985

has 'degree' => (
isa => 'Degree',
is => 'rw',
handles => {
graduated => 'awarded'
},
);

my $g = Graduate->new(name => 'Mike');
my $d = Degree->new(
awarded => '06-06-1985',
grade => 'IIii',
);
$g->degree($d);

print $g->graduated->year;
> 1985

More on attributes
package Student;
use MooseX::Util::TypeConstraints;
use Moose;
extends qw/Person/;
enum 'Result' => qw/pass fail/;
has classes => (
isa => 'HashRef[Result]',
is => 'rw',
predicate => 'has_classes',
);

Attribute Helpers
my $st = Student->new( name => 'Mike' );

$st->classes(
{ "Compilers" => 'fail',
"Numerical Methods" => 'pass' }
);

%{$st->classes}->{"Lisp"} = "pass";

Attribute Helpers (2)
use MooseX::AttributeHelpers;
has classes => (
metaclass => 'Collection::Hash',
isa => 'HashRef[Result]',
is => 'rw',
provides => {
set => 'add_class',
keys => 'list_classes',
}
)

Attribute Helpers (3)
my $st = Student->new( name => 'Mike' );

$st->classes(
{ "Compilers" => 'fail',
"Numerical Methods" => 'pass' }
);

$st->add_class("Lisp" => 'pass');
print join ", ", $st->list_classes();
> Compilers, Numerical Methods, Lisp

Introspecting Moose
• my $metaclass = $self->meta;

Introspecting Moose

• $metaclass->superclasses;

Introspecting Moose

• $metaclass->linearized_isa;

Introspecting Moose

• $metaclass->has_method("foo");

Introspecting Moose

• $metaclass->has_method("foo");
• $metaclass->get_all_attributes;

Method Signatures

• We have types...

Method Signatures

• Wouldn't it be nice if types weren't
restricted to attrs + accessors?

Method Signatures

• Wouldn't it be nice if types weren't
restricted to attrs + accessors?
• Enter: MooseX::Method::Signature

Method Signatures
package Student;
use Moose;
use MooseX::Method::Signatures;

method attend (Str $class, DateTime
$time) {
# ...
}

Method Signatures (2)
method attend
(Str $class, DateTime $time) {
if (grep $class,
$self->list_classes) {
$self->schedule($time, $class);
}
}

Even more Java-like?
use MooseX::Declare;

class Student extends Person with
Earnings {
has 'id' => ( isa => 'StudentID' );

method attend ( Str $class, ... ) {
# yadda yadda
}
}

Lasciate ogne
speranza,
voi ch'intrate

But seriously...

• Devel::Declare sticks the interpreter on
pause while it plays with your source

But seriously...

• NOT a source ﬁlter

But seriously...

• NOT a source ﬁlter
• You don't need to know what's going on...

Why Moose?
• Less code = fewer errors

Why Moose?
• Don't waste time on class implementation

Why Moose?
• Better object model

Why Moose?
• "We do this so you don't have to"

Why Moose?
• Less need for low level tests

Why Moose?
• Less need for low level tests
• More descriptive code

Further Reading

• http://iinteractive.com/moose/

Further Reading

• Moose::Cookbook (CPAN)

Further Reading

• Moose::Cookbook (CPAN)
• http://www.stonehenge.com/merlyn/
LinuxMag/col94.html

Complex Example
package Student;
use Moose;

# yadda

has 'id' => (
isa => 'StudentID',
is => 'rw',
);

Complex Example (2)
use MooseX::ClassAttribute;

class_has 'db' => (
isa => 'Str', is => 'rw',
default => 'dbi:SQLite:dbname=s.db'
);
class_has _schema => (
isa => 'Person::Schema',
lazy_build => 1, is => 'ro',
);

Complex Example (3)

sub _build__schema {
my $self = shift;
return Person::Schema->connect(
$self->db
);
}

Complex Example (4)
use Config::General;

override BUILDARGS => sub {
my $args = super;

my %conf = Config::General
->new( 'db.conf' )->getall();
$args->{db} = $conf{db}
if exists $conf{db};
};

Complex Example (5)
has _row => {
isa => 'DBIx::Class::Row',
lazy_build => 1,
}
sub _build__row {
return shift->_schema
->resultset('Student')
->find($self->id);
}

Complex Example (6)

has _row => {
isa => 'DBIx::Class::Row',
lazy_build => 1,
handles => [qw/address gender/],
}

Complex Example (7)
my $student = Student->new(
name => 'Mike', id => '3056',
);

print $st->address();

# What happens here?

What happens?
• address method is handled by _row

What happens?

• _row is lazy_build, so calls _build__row

What happens?


• which requires _schema, ALSO
lazy_build

What happens?


lazy_build

• which uses id to ﬁnd the right row in db

What happens?


lazy_build

• which uses id to ﬁnd the right row in db
• Tadaa!

But...
# What if the student's ID changes?

has 'id' => (
isa => 'StudentID',
is => 'rw',
trigger => '_build__row',
);

Introduction To Moose

More Related Content

What's hot (20)

Similar to Introduction To Moose (20)

Recently uploaded (20)

Introduction To Moose