Trait Moose::Role
2009 5 8

: Moose::Role
Perl Java interface
✤
requires API
✤
with API
✤
Perl gihyo.jp
✤
Trait
✤

: Mix-in (1)
✤
3
( Linux 2005 7 )
Mix-in Lisp
✤

: Mix-in (2)
Mix-in
✤
✤
Mix-in
✤
Mix-in
✤
✤
✤

: Mix-in (3)
Ruby
SuperClass
module MixinA
def mixin1
MixinB
print \"Hello Mixin A\\n\"
end
end
SubClass
module MixinC
def mixin2
MixinA
MixinC
mixin1
print \"Hello Mixin C\\n\"
end
SubSubClass
end
MixinA
class SubSubClass < SubClass
include MixinA
include MixinC
end
SuperClass2
SubSubClass.new.mixin2

Trait
OOP
✤
Mix-in
✤
2002 Traits: Composable Units of Behavior
✤

Trait
Perl 5(Moose) Perl 6
✤
JavaScript(Joose)
✤
Java(Scala)
✤
Ruby (module Mix-in )
✤
Fortress 2006 sun
✤
Smalltalk, PHP, ActionScript 3.0
✤

Trait Mix-in
Flatten
✤
(Perl Exporter )
✤
= Trait
✤
(with, import)
✤
Trait =
✤
Trait ( )
✤

Moose::Role Trait
(provided)
✤
(required)
✤
( OK)
✤
package TaxRole;
TaxRole
use Moose::Role;
requires 'price';
comsumption_tax price
our $TAX_RATE = 0.05;
tax_inclusive_price
sub consumption_tax{
return shift->price * $TAX_RATE;
}
sub tax_inclusive_price{
my $self = shift;
return $self->price + $self->consumption_tax;
}
no Moose::Role;

Moose::Role Trait
Trait
✤
required
✤
Goods
package Goods;
use Moose;
price
has price => (
isa => 'Int',
TaxRole
is => 'ro',
required => 1,
comsumption_tax price
);
tax_inclusive_price
with 'TaxRole';
no Moose;

Trait
sum : t1 + t2
✤
alias : t[a→b]
✤
exclusion : t - a
✤

Trait (1) - sum
package TraitsA;
required + provided = provided
✤
use Moose::Role;
required + required = required
✤
with 'TraitsB';
provided + provided = required ( )
✤
no Moose::Role;
TraitA TraitB TraitA
+= a ⇒
a c d b a
b d c c d

sum : ...
(m, ⊥: ,⟙: ) m1 ⊔ ⟙ = ⟙
→ ✤
✤
⟘⊔⟙=⟙
✤
⟘ ⊔⟘=⟘
✤
⟙⊔⟙=⟙
✤
m1 ⊔ ⟘ = m1
✤
provided: ⊥ ⟙
✤
m1 ⊔ m1 = m1
✤
m1 ⊔ m2 = ⟙ required: - provided
✤ ✤
TraitA TraitB TraitA
+= a = m3, c = m4 ⇒
a = m1, b = m2 b = m2, c = m4
c = ⟘, d = ⟘ d=⟘ a = ⟙, d = ⟘

Trait (2) - alias
package AnotherTraits;
use Moose::Role;
→
✤
with 'TraitsA' => {
alias => {a => 'e'},
};
no Moose::Role;
TraitA TraitA
[e → a] ⇒
a c a c
b d b d
e

Trait (3) - exclusion
package AnotherTraits;
use Moose::Role;
−
✤
with 'TraitsA' => {
excludes => ['a'],
};
no Moose::Role;
TraitA TraitA
-= a ⇒
a c b c
b d d

Trait :
package TraitsA;
use Moose::Role;
TraitA
with 'TraitsB' => {
a b
alias => {b => 'e'},
excludes => ['c'], c
}; d
e
no Moose::Role;
TraitA TraitB
a d += ( b a [e → b] - c )
b c
c d

Trait :
package TraitsA;
use Moose::Role;
TraitA
with 'TraitsB' => {
a b
alias => {b => 'e'},
excludes => ['c'], c
}; d
e
no Moose::Role;
TraitA TraitB
+= ( b = e
a d a [e → b] - c )
=
b c
c d

Trait
✤
package Trait; package Class;
use Moose::Role; use Moose;
sub class_vs_trait{ print __PACKAGE__, \"\\n\"; } extends 'SuperClass'; with 'Trait';
sub super_vs_trait{ print __PACKAGE__, \"\\n\"; } sub class_vs_trait{ print __PACKAGE__, \"\\n\"; }
no Moose::Role; no Moose;
package SuperClass; package main;
use Moose; my $c = Class->new;
sub super_vs_trait{ print __PACKAGE__, \"\\n\"; } $c->class_vs_trait;
no Moose; $c->super_vs_trait;

Class 1 SuperClass 1 (∵ )
✤
Trait Trait
⇒
Trait required
✤
(Mix-in )
⇒
✤
✤
alias exclusion
✤

package TraitA;
use Moose::Role; package Class;
sub vs{ print __PACKAGE__, \"\\n\" } use Moose;
no Moose::Role; with 'TraitA', 'TraitB';
no Moose;
package TraitB;
use Moose::Role; package main;
sub vs{ print __PACKAGE__, \"\\n\" } Class->new->vs;
no Moose::Role;

Trait
state( ) Trait
✤
→ has
✤
Trait
✤
→
✤

✤
Trait
✤
Trait Mix-in
✤