This document provides an introduction and overview of Moose, a modern object framework for Perl 5. It begins with background on the author and a brief history of object oriented programming in Perl 5. It then explains what Moose is, including that it handles object overhead, allows for introspection, and is used in production software. Examples are provided of basic class creation and usage with Moose as well as more advanced features like attributes, types, subclassing, roles, method modifiers, and introspection. The benefits of Moose are summarized as writing less code and avoiding implementation details to have a better object model.

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

2. About me

3. About me
• BBC iPlayer team

4. About me
• BBC iPlayer team
• ex-Yahoo Europe (News team)

5. About me
• BBC iPlayer team
• ex-Yahoo Europe (News team)
• ex-CricInfo.com

6. About me
• BBC iPlayer team
• ex-Yahoo Europe (News team)
• ex-CricInfo.com
• Board member of EnlightenedPerl.org

7. Why Moose?

8. Why Moose?
• For that, we need a bit of history:

9. In the Beginning...

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

11. In the Beginning...
• ...there was Perl 5
• DIY OO

12. In the Beginning...
• ...there was Perl 5
• DIY OO
• perldoc perltoot

13. In the Beginning...
• ...there was Perl 5
• DIY OO
• perldoc perltoot
package Foo;
sub new {
my $self = {};
return bless $self;
}

14. 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 (defined $val) {
$self->{bar} = $val;
sub new { }
my $self = {}; else {
return bless $self; return $self->{bar};
} }
}

15. Perl 5 Native OO

16. Perl 5 Native OO
• A bit of a hack

17. Perl 5 Native OO
• A bit of a hack
• Not really a first-class part of the language

18. Perl 5 Native OO
• A bit of a hack
• Not really a first-class part of the language
• Have to roll your own

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

21. Class::Accessor::Classy Class::Accessor
Object::InsideOut fields
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::Define
Abstract::Meta::Class

22. Moose

23. What is Moose?

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

25. What is Moose?
• (Post)modern Perl OO framework
• Deals with the overhead of implementing
OO, allows you to get on with coding

26. What is Moose?
• (Post)modern Perl OO framework
• Deals with the overhead of implementing
OO, allows you to get on with coding
• Meta-object implementation - allows you to
introspect your classes and objects

27. What is Moose?
• (Post)modern Perl OO framework
• Deals with the overhead of implementing
OO, allows you to get on with coding
• Meta-object implementation - allows you to
introspect your classes and objects
• Already used in production software

28. My First Class
package Person;
use Moose;
has name => (
is => 'rw',
);
no Moose;

29. Using the class
use Person;
my $person = Person->new();
$person->name('Mike');
print $person->name();
> Mike

30. Adding a method
package Person;
use Moose;
has name => ( is => 'rw' );
sub introduce {
print "I'm " . $self->name;
}

31. Using it
use Person;
my $person = Person->new();
$person->name('Mike');
$person->introduce();
> I'm Mike

32. Read-only attributes
package Person;
use Moose;
has name => ( is => 'ro' );
sub introduce {
print "I'm " . $self->name;
}

33. Read-only attributes (2)
use Person;
my $person = Person->new();
$person->name('Mike');
# boom!

34. Read-only attributes (3)
use Person;
my $person = Person->new(
{ name => 'Mike' },
);
# no boom today!

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

36. Types
package Person;
use Moose;
has name => (
is => 'rw',
isa => 'Str',
);

37. Types (2)
use Person;
my $person = Person->new();
$person->name('Mike');
# shiny!
$person->name( [] );
# boom!
# Not a Str

38. Types (3)
package Person;
use Moose;
has name => ( is => 'rw', isa => 'Str' );
has dob => (
is => 'rw',
isa => 'DateTime',
);

39. 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

40. Subclassing
package Student;
use Moose;
extends qw/Person/;
has overdraft => (
isa => 'Bool',
is => 'rw',
);

41. Compound Types
package Student;
use Moose;
extends qw/Person/;
has classes => (
isa => 'HashRef[Str]',
is => 'rw',
);

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

43. Setting defaults
package Student;
use Moose;
has 'overdraft' => (
isa => 'Bool',
default => 1,
);

44. But, what if...
package BankAccount;
sub balance {
# yadda yadda
}

45. And then...
package Student;
use Moose;
extends qw/Person/;
has 'account' => (
isa => 'BankAccount',
is => 'rw',
required => 1,
);

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

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

48. Method modifiers
package Student;
# yadda yadda
after 'introduce' => sub {
my $self = shift;
print ', studying ' . $self->course;
}

49. Using it
use Student;
my $person = Student->new(
name => 'Mike',
course => 'Computer Science',
);
$person->introduce();
> I'm Mike, studying Computer Science

50. Method modifiers (2)
package Student;
# yadda yadda
around 'introduce' => sub {
my ($next, $self, @args) = @_;
print "Hi, ";
$self->$next(@args);
print ', studying ' . $self->course;
}

51. Using around
use Student;
my $person = Student->new(
name => 'Mike',
course => 'Computer Science',
);
$person->introduce();
> Hi, I'm Mike, studying Computer Science

52. Roles

53. Roles
• Code fragments that define and provide a
small, reusable behaviour

54. Roles
• Code fragments that define and provide a
small, reusable behaviour
• Not inherited - methods become part of
consuming class

55. Roles
• Code fragments that define and provide a
small, reusable behaviour
• Not inherited - methods become part of
consuming class
• can be overriden by comsuming class

56. Roles
• Code fragments that define and provide a
small, reusable behaviour
• Not inherited - methods become part of
consuming class
• can be overriden by comsuming class
• like MI but better!

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

58. 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;
}

59. Using a role (2)
use Student;
my $person = Student->new(
name => 'Mike',
dob => ... # yadda yadda
course => 'CS',
);
$person->introduce();
> Hi, I'm Mike, age 45, studying CS

60. What we'd really like
use Student;
my $person = Student->new(
name => 'Mike',
dob => '05-08-1963',
course => 'CS',
);

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

62. Types to the rescue
use Moose::Util::TypeConstraints;
subtype 'DateStr'
=> as 'Str'
=> where {
/^dd-dd-dddd$/
};

63. 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
);
};

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

65. Et voila...
use Student;
my $person = Student->new(
name => 'Mike',
dob => '05-08-1963',
course => 'CS',
);
print $person->age();
> 45

66. Roles as interfaces
package Earnings;
use Moose::Role;
requires qw/annual_income/;
sub monthly_income {
return shift->annual_income / 12;
}

67. Roles as interfaces (2)
package Person;
with qw/Earnings/;
package Student;
extends qw/Person/;
sub annual_income {
my $self = shift;
return $self->grant_amount;
}

68. Role gotchas

69. Role gotchas
• Roles cannot use extends

70. Role gotchas
• Roles cannot use extends
• requires only works with actual methods :(

71. Role gotchas
• Roles cannot use extends
• requires only works with actual methods :(
• for now, at least

72. Role gotchas
• Roles cannot use extends
• requires only works with actual methods :(
• for now, at least
• watch out for method and attribute
conflicts

73. 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,
);

74. Method Delegation (2)
package Graduate;
use Moose;
extends qw/Student/;
has 'degree' => (
isa => 'Degree',
is => 'rw',
);

75. Method Delegation (3)
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

76. Method Delegation (4)
has 'degree' => (
isa => 'Degree',
is => 'rw',
handles => {
graduated => 'awarded'
},
);

77. Method Delegation (5)
my $g = Graduate->new(name => 'Mike');
my $d = Degree->new(
awarded => '06-06-1985',
grade => 'IIii',
);
$g->degree($d);
print $g->graduated->year;
> 1985

78. 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',
);

79. Attribute Helpers
my $st = Student->new( name => 'Mike' );
$st->classes(
{ "Compilers" => 'fail',
"Numerical Methods" => 'pass' }
);
%{$st->classes}->{"Lisp"} = "pass";

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

81. 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

82. Introspecting Moose

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

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

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

86. Introspecting Moose
• my $metaclass = $self->meta;
• $metaclass->superclasses;
• $metaclass->linearized_isa;

87. Introspecting Moose
• my $metaclass = $self->meta;
• $metaclass->superclasses;
• $metaclass->linearized_isa;
• $metaclass->has_method("foo");

88. Introspecting Moose
• my $metaclass = $self->meta;
• $metaclass->superclasses;
• $metaclass->linearized_isa;
• $metaclass->has_method("foo");
• $metaclass->get_all_attributes;

89. Method Signatures

90. Method Signatures
• We have types...

91. Method Signatures
• We have types...
• Wouldn't it be nice if types weren't
restricted to attrs + accessors?

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

93. Method Signatures
package Student;
use Moose;
use MooseX::Method::Signatures;
method attend (Str $class, DateTime
$time) {
# ...
}

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

95. Even more Java-like?
use MooseX::Declare;
class Student extends Person with
Earnings {
has 'id' => ( isa => 'StudentID' );
method attend ( Str $class, ... ) {
# yadda yadda
}
}

96. How is this
implemented?

98. Lasciate ogne
speranza,
voi ch'intrate

100. But seriously...

101. But seriously...
• Devel::Declare sticks the interpreter on
pause while it plays with your source

102. But seriously...
• Devel::Declare sticks the interpreter on
pause while it plays with your source
• NOT a source filter

103. But seriously...
• Devel::Declare sticks the interpreter on
pause while it plays with your source
• NOT a source filter
• You don't need to know what's going on...

104. Why Moose?

105. Why Moose?
• Less code = fewer errors

106. Why Moose?
• Less code = fewer errors
• Don't waste time on class implementation

107. Why Moose?
• Less code = fewer errors
• Don't waste time on class implementation
• Better object model

108. Why Moose?
• Less code = fewer errors
• Don't waste time on class implementation
• Better object model
• "We do this so you don't have to"

109. Why Moose?
• Less code = fewer errors
• Don't waste time on class implementation
• Better object model
• "We do this so you don't have to"
• Less need for low level tests

110. Why Moose?
• Less code = fewer errors
• Don't waste time on class implementation
• Better object model
• "We do this so you don't have to"
• Less need for low level tests
• More descriptive code

111. Further Reading

112. Further Reading
• http://iinteractive.com/moose/

113. Further Reading
• http://iinteractive.com/moose/
• Moose::Cookbook (CPAN)

114. Further Reading
• http://iinteractive.com/moose/
• Moose::Cookbook (CPAN)
• http://www.stonehenge.com/merlyn/
LinuxMag/col94.html

116. Complex Example
package Student;
use Moose;
# yadda
has 'id' => (
isa => 'StudentID',
is => 'rw',
);

117. 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',
);

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

119. 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};
};

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

121. Complex Example (6)
has _row => {
isa => 'DBIx::Class::Row',
lazy_build => 1,
handles => [qw/address gender/],
}

122. Complex Example (7)
my $student = Student->new(
name => 'Mike', id => '3056',
);
print $st->address();
# What happens here?

123. What happens?

124. What happens?
• address method is handled by _row

125. What happens?
• address method is handled by _row
• _row is lazy_build, so calls _build__row

126. What happens?
• address method is handled by _row
• _row is lazy_build, so calls _build__row
• which requires _schema, ALSO
lazy_build

127. What happens?
• address method is handled by _row
• _row is lazy_build, so calls _build__row
• which requires _schema, ALSO
lazy_build
• which uses id to find the right row in db

128. What happens?
• address method is handled by _row
• _row is lazy_build, so calls _build__row
• which requires _schema, ALSO
lazy_build
• which uses id to find the right row in db
• Tadaa!

129. But...
# What if the student's ID changes?
has 'id' => (
isa => 'StudentID',
is => 'rw',
trigger => '_build__row',
);