Roles are an excellent object-oriented tool both for allomorphism and for reuse. Roles facilitate allomorphism by favoring "does this object do X" versus "is this object a subclass of X". You often care more about capability than inheritance. In a sense, roles encode types better than inheritance. Roles also provide an excellent faculty for reuse. This effectively eliminates multiple inheritance, which is often the only solution for sharing code between unrelated classes. Roles can combine with conflict detection. This eliminates accidental shadowing of methods that is painful with multiple inheritance and mixins. Parameterized roles (via MooseX::Role::Parameterized) improve the reusability of roles by letting each consumer cater the role to its needs. This does sacrifice some allomorphism, but there are ways to restore it.

1. (Parameterized)
Roles
Shawn M Moore
Best Practical Solutions
http://sartak.org

2. "The more I use roles, the less I
understand why anyone would
want to use the inheritance
model." - Ovid
"A role-aware type system allows
you to express yourself with
better genericity."
- chromatic
"Roles are the sound of diamond
inheritance that people have
stopped banging their heads
against." - hdp
( )

3. Example Role
package Counter;
use Moose::Role;
has counter => (
is => 'ro',
isa => 'Int',
default => 0,
);
sub increment {
my $self = shift;
$self->counter($self->counter + 1);
}

4. Example Role
package Counter;
use Moose::Role;
has counter => (
is => 'ro',
isa => 'Int',
default => 0,
);
sub increment {
my $self = shift;
$self->counter($self->counter + 1);
}
use Moose

5. Example Role
use MooseX::Declare;
role Counter {
has counter => (
is => 'ro',
isa => 'Int',
default => 0,
);
method increment {
$self->counter($self->counter + 1);
}
}

6. Consuming a Role
class Odometer with Counter {
method reset(Crook $you) {
$you->break_into($self);
$self->counter(0);
$you->plead('innocent');
}
}
with

7. Odometer Fraud
http://en.wikipedia.org/wiki/Odometer_fraud

8. Consuming a Role
class Odometer with Counter {
method reset(Crook $you) {
$you->break_into($self);
$self->counter(0);
$you->plead('innocent');
}
}
counter

9. Consuming a Role
class Odometer extends Widget with Counter {
method reset(Crook $you) {
$you->break_into($self);
$self->counter(0);
$you->plead('innocent');
}
}

10. class Odometer extends Widget {
has counter => (
is => 'ro',
isa => 'Int',
default => 0,
);
method increment {
$self->counter($self->counter + 1);
}
method reset(Crook $you) {
$you->break_into($self);
$self->counter(0);
$you->plead('innocent');
}
}

11. Class Building
Blocks
class Action::Throw
with Action::Role::Direction
with Action::Role::Item {
…
}
class Action::Melee
with Action::Role::Monster
with Action::Role::Direction {
…
}

12. Class Building
Blocks
class Action::Throw
with Action::Role::Direction
with Action::Role::Item {
…
}
class Action::Melee
with Action::Role::Monster
with Action::Role::Direction {
…
}

13. Class Building
Blocks
class Action::Throw
extends Action::Direction
extends Action::Item {
…
}
class Action::Melee
extends Action::Monster
extends Action::Direction {
…
}

14. Multiple Inheritance
class Action::Monster {
has monster => (…);
method name {
$self->monster->name
}
}

15. Multiple Inheritance
class Action::Direction {
has direction => (…);
}
direction

16. Multiple Inheritance
class Action::Melee
extends Action::Direction
extends Action::Monster {
…
}
…

17. Multiple Inheritance
class Action::Direction {
has direction => (…);
method name {
$self->direction->name
}
}
name

18. Multiple Inheritance
$melee->name
name

19. Multiple Roles
class Action::Melee
with Action::Direction
with Action::Monster {
…
}

20. Multiple Roles
Due to a method name conflict in roles
'Action::Direction' and 'Action::Monster', the
method 'name' must be implemented or
excluded by 'Action::Melee'
Moose

21. AT
COMPILE
TIME!
!

22. Conflict Resolution
class Action::Melee
with Action::Direction
with Action::Monster {
…
}

23. Conflict Resolution
class Action::Melee
with Action::Direction
with Action::Monster {
method name { "melee" }
}

24. Conflict Resolution
class Action::Melee
with Action::Direction
with Action::Monster excludes name
{…}

25. class Action::Melee
with Action::Direction
alias { name => 'direction_name' }
with Action::Monster
alias { name => 'monster_name' }
{
method name {
loc '%1 (at %2)',
$self->monster_name,
$self->direction_name;
}
}
2

26. Conflict Resolution
Due to a method name conflict in roles
'Action::Direction' and 'Action::Monster', the
method 'name' must be implemented or
excluded by 'Action::Melee'

27. Conflict Resolution
Due to a method name conflict in roles
'Action::Direction' and 'Action::Monster', the
method 'name' must be implemented or
excluded by 'Action::Melee'

28. Conflict Resolution
Due to a method name conflict in roles
'Action::Direction' and 'Action::Monster', the
method 'name' must be implemented or
excluded by 'Action::Melee'

29. Conflict Resolution
class Action::Melee
extends Action::Direction
extends Action::Monster
excludes name
{…}

30. "Roles are the
sound of diamond
inheritance that
people have
stopped banging
their heads against."
- hdp

31. Required Methods
role Action::Role::Monster {
method monster {
$self->tile->monster
}
method has_monster {
$self->tile->has_monster
}
}

32. Required Methods
class Action::Chat
with Action::Role::Monster {
method run { print "woof" }
}

33. Required Methods
$chat->has_monster

34. Required Methods
Can't locate object method "tile" via package
"Action::Chat"
tile

35. Required Methods
role Action::Role::Monster {
requires 'tile';
method monster {
$self->tile->monster
}
method has_monster {
$self->tile->has_monster
}
}

36. Required Methods
'Action::Role::Monster' requires the method
'tile' to be implemented by 'Action::Chat'

37. Default
Implementation
role Scan {
requires 'entries';
method ages {
map { $_->age }
$self->entries
}
}

38. Default
Implementation
class Backend::Hash with Scan {
method entries {
values %{ $self->storage }
}
}

39. Default
Implementation
class Backend::DBI with Scan {
method entries {
$self->q("SELECT * …");
}
method ages {
$self->q("SELECT age …");
}
}

40. Default
Implementation
class Backend::DBI with Scan {
method entries {
$self->q("SELECT * …");
}
method ages {
$self->q("SELECT age …");
}
}

41. Default
Implementation
class Backend::DBI with Scan {
method entries {
$self->q("SELECT * …");
}
method ages {
$self->q("SELECT age …");
}
}
Scan

42. "The more I use
roles, the less I
understand why
anyone would want
to use the
inheritance model."
- Ovid

43. Allomorphism
Role = Type

44. Allomorphism
Role = Semantics

45. Allomorphism
Role = Type
Role = Semantics

46. Allomorphism
role Interface::Nonblocking {
requires 'read', 'write';
}
read write

47. Allomorphism
class Nonblocking::Socket
with Interface::Nonblocking {
method read { … }
method write { … }
}

48. Allomorphism
class Blocking::Socket {
method read { … }
method write { … }
}

49. Allomorphism
my $s = shift;
$s->does('Interface::Nonblocking')
or confess 'No blocking!';
$s->write(' ');

50. Duck Typing
my $s = shift;
$s->can('read') && $s->can('write')
or confess 'Need an interface';
$s->write(' ');

51. Allomorphism
my $s = shift;
$s->does('Interface::Nonblocking')
or confess 'No blocking!';
$s->write(' ');
write

52. Allomorphism
has connection => (
isa => 'Nonblocking::Socket',
);

53. Allomorphism
has connection => (
isa => 'Nonblocking::Socket',
does => 'Interface::Nonblocking',
);

54. "A role-aware type
system allows you
to express yourself
with better
genericity."
- chromatic

55. Extensions
class WWW::Mechanize::TreeBuilder
extends WWW::Mechanize {
has tree => (
…
);
around _make_request {
…
}
}

56. Extensions
class Test::WWW::Mech::TreeBuilder
extends Test::WWW::Mechanize {
has tree => (
…
);
around _make_request {
…
}
}

57. Extensions
class WWW::Mech::Cache::TreeBuilder
extends WWW::Mechanize::Cached {
has tree => (
…
);
around _make_request {
…
}
}
Mech

58. Extensions
BAD!

59. Extensions
role WWW::Mechanize::TreeBuilder {
has tree => (
…
);
around _make_request {
…
}
}

60. Extensions
class Test::WWW::Mech::TreeBuilder
extends Test::WWW::Mechanize
with WWW::Mechanize::TreeBuilder {}

61. Extensions
class WWW::Mech::Cache::TreeBuilder
extends WWW::Mechanize::Cached
with WWW::Mechanize::TreeBuilder {}

62. Extensions
Roles >
Inheritance

63. Role -> Object
role Rootey {
method su { … }
}
$jrock = User->new("jrockway");
$shawn = User->new("sartak");
Rootey->meta->apply($shawn);
$shawn->su; # ok
$jrock->su; # dies!

64. Plugins
MooseX::Object::Pluggable
MooseX::Traits

65. Classes are Nouns
Message
User
Service
Request
Response

66. Methods are Verbs
send_message
add_user
connect_to_service
handle_request
serve_response

67. Roles are Adjectives
HasPlugins
RequiresPlugins
Throwable
Reblessing
ExtendsObject::User

68. Parameterized Roles
role Scan {
requires 'entries';
method ages {
map { $_->age }
$self->entries
}
}

69. Parameterized Roles
MooseX::Role::Parameterized
Moose

70. Parameterized Roles
role Counter (Int :$default = 0) {
has counter => (
is => 'ro',
isa => 'Int',
default => $default,
);
sub increment {
my $self = shift;
$self->counter($self->counter + 1);
}
}

71. Parameterized Roles
class Odometer
with Counter(default => 10000) {
…
}
66

72. Parameterized Roles
role Speedometer (Str :$method) {
around $method {
my $start = time;
$orig->(@_);
print "$method " . (time - $start);
}
}
66

73. Parameterized Roles
role WWW::Search (Str :$engine) {
method search (Str $query) {
if ($engine eq "Google") {
REST::Google::Search->…
} elsif ($engine eq "Yahoo!") {
Yahoo::Search->…
} elsif ($engine eq "Bing") {
die "seriously?";
}
# post-process @results
}
}
66

74. Parameterized Roles
package Valid::Adding;
use MooseX::Role::Parameterized;
role {
$consumer->does('Adding') or die;
$consumer->add(2, 6) == 8 or die;
method safe_add => sub {
…
};
};
66

75. Roles
Class building blocks
Conflicts, resolution
Required methods
Allomorphism (types)
Extensions, Plugins
"adjectives"

76. Thanks to my
Vlad Dogsby
Thomas Figg
Alexander Hoffer
Stevan Little
Lucas Oman
Simon Pollard

77. Thanks to my
Kenichi Ishigaki
charsbar++

78. See Also
Moose::Manual::Roles
"The Why of Perl Roles"
"Eliminating Inheritance via Smalltalk-Style
Traits"
"Traits - Composing Classes from Behavioral
Building Blocks"