moose-class/slides/index.html

   1 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">
   2
   3 <html xmlns="http://www.w3.org/1999/xhtml">
   4
   5 <head>
   6 <title>Introduction to Moose</title>
   7 <meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
   8 <!-- metadata -->
   9 <meta name="generator" content="S5" />
  10 <meta name="version" content="S5 1.2a2" />
  11 <meta name="author" content="Eric A. Meyer" />
  12 <meta name="company" content="Complex Spiral Consulting" />
  13 <!-- configuration parameters -->
  14 <meta name="defaultView" content="slideshow" />
  15 <meta name="controlVis" content="hidden" />
  16 <!-- style sheet links -->
  17 <link rel="stylesheet" href="ui/default/slides.css" type="text/css" media="projection" id="slideProj" />
  18 <link rel="stylesheet" href="ui/default/outline.css" type="text/css" media="screen" id="outlineStyle" />
  19 <link rel="stylesheet" href="ui/default/print.css" type="text/css" media="print" id="slidePrint" />
  20 <link rel="stylesheet" href="ui/default/opera.css" type="text/css" media="projection" id="operaFix" />
  21 <!-- embedded styles -->
  22 <style type="text/css" media="all">
  23 .imgcon {width: 525px; margin: 0 auto; padding: 0; text-align: center;}
  24 #anim {width: 270px; height: 320px; position: relative; margin-top: 0.5em;}
  25 #anim img {position: absolute; top: 42px; left: 24px;}
  26 img#me01 {top: 0; left: 0;}
  27 img#me02 {left: 23px;}
  28 img#me04 {top: 44px;}
  29 img#me05 {top: 43px;left: 36px;}
  30 </style>
  31 <!-- S5 JS -->
  32 <script src="ui/default/slides.js" type="text/javascript"></script>
  33 <link rel="stylesheet" href="ui/custom.css" type="text/css" />
  34 </head>
  35 <body>
  36
  37 <div class="layout">
  38 <div id="controls"><!-- DO NOT EDIT --></div>
  39 <div id="currentSlide"><!-- DO NOT EDIT --></div>
  40 <div id="header"></div>
  41 <div id="footer">
  42   <div id="license">
  43     <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/us/"><img alt="Creative Commons License" style="border-width:0" src="http://i.creativecommons.org/l/by-sa/3.0/us/88x31.png" /></a>
  44     <br /><span xmlns:dc="http://purl.org/dc/elements/1.1/" href="http://purl.org/dc/dcmitype/Text" property="dc:title" rel="dc:type">Introduction to Moose</span> by <span xmlns:cc="http://creativecommons.org/ns#" property="cc:attributionName">David Rolsky</span> is licensed under a <a rel="license" href="http://creativecommons.org/licenses/by-sa/3.0/us/">Creative Commons Attribution-Share Alike 3.0 United States License</a>.
  45   </div>
  46
  47   <h2>Introduction to Moose</h2>
  48 </div>
  49 </div>
  50
  51 <div class="presentation">
  52
  53 <div class="slide">
  54   <h1>Introduction to Moose</h1>
  55   <h2><a href="git://git.moose.perl.org/moose-presentations.git"><tt>git://git.moose.perl.org/moose-presentations.git</tt></a></h2>
  56 </div>
  57
  58 <div class="slide">
  59   <h1>Moose Summed Up</h1>
  60
  61   <ul>
  62     <li><strong>Declarative</strong> OO sugar</li>
  63     <li>Introspectable</li>
  64     <li>Extensible (MooseX::* on CPAN)</li>
  65   </ul>
  66 </div>
  67
  68 <div class="slide">
  69   <h1>Moose Background</h1>
  70
  71   <ul>
  72     <li>Created by Stevan Little, first released in 2006</li>
  73     <li>Moose builds on Perl 5's native OO</li>
  74     <li>Borrows ideas from other languages, notably Perl 6</li>
  75     <li>Provides semantics for common operations</li>
  76   </ul>
  77 </div>
  78
  79 <div class="slide fake-slide0">
  80   <h1>Part 0: Moose Concepts</h1>
  81 </div>
  82
  83 <div class="slide">
  84   <h1>Classes</h1>
  85
  86   <ul>
  87     <li>
  88       Classes have ...
  89       <ul>
  90         <li>Attributes</li>
  91         <li>Methods</li>
  92         <li>Superclasses</li>
  93         <li>Method modifiers</li>
  94         <li>Constructor and destructor</li>
  95         <li>One metaclass object</li>
  96       </ul>
  97     </li>
  98     <li>Classes do roles</li>
  99   </ul>
 100 </div>
 101
 102 <div class="slide">
 103   <h1>Class Example</h1>
 104
 105   <pre><code>package Person;
 106 <span class="highlight">use Moose;</span></code></pre>
 107
 108   <ul>
 109     <li>Poof, a Moose-based class!</li>
 110   </ul>
 111 </div>
 112
 113 <div class="slide">
 114   <h1>Attributes</h1>
 115
 116   <ul>
 117     <li>Aka property, slot, field, member variable</li>
 118     <li>A piece of data owned by an object</li>
 119   </ul>
 120 </div>
 121
 122 <div class="slide">
 123   <h1>Attributes</h1>
 124
 125   <ul>
 126     <li>
 127       Attributes have ...
 128       <ul>
 129         <li>Access-control (read-only vs read-write)</li>
 130         <li>An optional type</li>
 131         <li>Accessor methods</li>
 132         <li>Delegation methods</li>
 133         <li>Optional default value</li>
 134         <li>Many more features</li>
 135       </ul>
 136     </li>
 137     <li>Stored in the object, but don't worry about that</li>
 138   </ul>
 139 </div>
 140
 141 <div class="slide">
 142   <h1>Attribute Example</h1>
 143
 144   <pre><code>package Person;
 145 use Moose;
 146
 147 <span class="highlight">has first_name =&gt; ( is =&gt; 'rw' );</span></code></pre>
 148
 149 </div>
 150
 151 <div class="slide">
 152   <h1>Methods</h1>
 153
 154   <ul>
 155     <li>Nothing fancy here, just Perl subroutines</li>
 156   </ul>
 157
 158   <pre><code>package Person;
 159 use Moose;
 160
 161 <span class="highlight">sub greet { ... }</span></code></pre>
 162 </div>
 163
 164 <div class="slide">
 165   <h1>Roles</h1>
 166
 167   <ul>
 168     <li>Classes <strong>do</strong> (or consume) roles</li>
 169     <li>Similar to mixins and Java interfaces</li>
 170   </ul>
 171 </div>
 172
 173 <div class="slide">
 174   <h1>Roles</h1>
 175
 176   <ul>
 177     <li>Like classes, can have attributes, methods, do roles</li>
 178     <li>Roles can require methods</li>
 179     <li>Roles are composed (flattened) into classes</li>
 180   </ul>
 181 </div>
 182
 183 <div class="slide">
 184   <h1>Role Example</h1>
 185
 186 <pre><code>package HasPermissions;
 187 <span class="highlight">use Moose::Role;</span>
 188
 189 has is_admin =&gt; ( is =&gt; 'rw' );</code></pre>
 190 </div>
 191
 192 <div class="slide">
 193   <h1>Role Example</h1>
 194
 195   <p>
 196     And then ...
 197   </p>
 198
 199 <pre><code>package Person;
 200 use Moose;
 201
 202 <span class="highlight">with 'HasPermissions';</span></code></pre>
 203 </div>
 204
 205 <div class="slide">
 206   <h1>Method Modifiers</h1>
 207
 208   <ul>
 209     <li>AKA advice</li>
 210     <li>&quot;<strong>Before</strong> foo(), do this first&quot;</li>
 211     <li>&quot;Do this <strong>after</strong> foo()</li>
 212     <li>&quot;Put this code <strong>around</strong> foo()&quot;</li>
 213   </ul>
 214 </div>
 215
 216 <div class="slide">
 217   <h1>Before and After</h1>
 218
 219 <pre><code>before 'foo'
 220     =&gt; sub { warn 'About to call foo()' };
 221
 222 after  'foo'
 223     =&gt; sub { warn 'Leaving foo()' };</code></pre>
 224
 225 </div>
 226
 227 <div class="slide">
 228   <h1>Around</h1>
 229
 230 <pre><code>around 'foo' =&gt; sub {
 231     my $real_foo = shift;
 232     my $self     = shift;
 233
 234     warn 'Just before foo()';
 235     my @return =
 236         $self-&gt;$real_foo( @_, bar =&gt; 42 );
 237
 238     return ( @return, 'modify return values' );
 239 };</code></pre>
 240 </div>
 241
 242 <div class="slide">
 243   <h1>Type Constraints</h1>
 244
 245   <ul>
 246     <li>NOT A FULL-BLOWN TYPE SYSTEM!</li>
 247     <li>But still darn useful</li>
 248     <li>Constrain attribute values</li>
 249     <li>Coerce from other types</li>
 250   </ul>
 251 </div>
 252
 253 <div class="slide">
 254   <h1>Type Constraint Example</h1>
 255
 256 <pre><code>package Person;
 257 use Moose;
 258
 259 has weight =&gt; (
 260     is  =&gt; 'ro',
 261     <span class="highlight">isa =&gt; 'Int'</span>,
 262 );
 263
 264 # kaboom
 265 Person-&gt;new( weight =&gt; 'fat' );</code></pre>
 266 </div>
 267
 268 <div class="slide">
 269   <h1>Delegation</h1>
 270
 271   <ul>
 272     <li>Attributes can define delegations</li>
 273     <li>Lets you hide some implementation details</li>
 274     <li>Fewer objects to chase around</li>
 275   </ul>
 276 </div>
 277
 278 <div class="slide">
 279   <h1>Delegation</h1>
 280
 281 <pre><code>package Person;
 282 use Moose;
 283
 284 has blog_uri =&gt; (
 285     is      =&gt; 'rw',
 286     isa     =&gt; 'URI',
 287     <span class="highlight">handles =&gt; { 'blog_hostname' =&gt; 'host' },</span>
 288 );
 289
 290 <span class="highlight">$person->blog_hostname;</span>
 291 # really calls $person->blog_uri->host</code></pre>
 292 </div>
 293
 294 <div class="slide">
 295   <h1>Constructors</h1>
 296
 297   <ul>
 298     <li>Moose creates <code>new()</code> for you</li>
 299     <li>Provide an optional <code>BUILDARGS()</code> and <code>BUILD()</code></li>
 300   </ul>
 301 </div>
 302
 303 <div class="slide">
 304   <h1>Destructors</h1>
 305
 306   <ul>
 307     <li>Provide an optional <code>DEMOLISH()</code></li>
 308   </ul>
 309 </div>
 310
 311 <div class="slide">
 312   <h1>Moose Meta-API</h1>
 313
 314   <ul>
 315     <li>Answers questions like ...
 316       <ul>
 317         <li>What methods does this class have?</li>
 318         <li>What are its parents?</li>
 319         <li>What attributes does it have (including inherited attributes)?</li>
 320         <li>What roles does it do?</li>
 321         <li>Much, much, more</li>
 322       </ul>
 323     </li>
 324   </ul>
 325 </div>
 326
 327 <div class="slide">
 328   <h1>Moose Meta-API</h1>
 329
 330   <ul>
 331     <li>Not just for introspection ...
 332       <ul>
 333         <li>Add methods, attributes, roles, etc</li>
 334         <li>Extend and alter core features</li>
 335       </ul>
 336     </li>
 337   </ul>
 338 </div>
 339
 340 <div class="slide">
 341   <h1>Why Moose?</h1>
 342
 343   <ul>
 344     <li>A quick bit of propaganda ...</li>
 345   </ul>
 346 </div>
 347
 348 <div class="slide">
 349   <h1>With Moose</h1>
 350
 351   <pre><code>package Person;
 352 use Moose;
 353
 354 has last_name =&gt; (
 355     is  =&gt; 'rw',
 356     isa =&gt; 'Str',
 357 );</code></pre>
 358 </div>
 359
 360 <div class="slide">
 361     <h1>Without Moose</h1>
 362
 363     <pre class="small"><code>package Person;
 364 use strict;
 365 use warnings;
 366 use Carp 'confess';
 367
 368 sub new {
 369     my $class = shift;
 370     my %args  = @_;
 371     my $self  = {};
 372
 373     if (exists $args{last_name}) {
 374         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 375                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 376             if ref($args{last_name});
 377         $self-&gt;{last_nane} = $args{last_name};
 378     }
 379
 380     return bless $self, $class;
 381 }
 382
 383 sub last_name {
 384     my $self = shift;
 385
 386     if (@_) {
 387         my $value = shift;
 388         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 389                 . &quot;Validation failed for 'Str' with value $value&quot;
 390             if ref($value);
 391         $self-&gt;{last_name} = $value;
 392     }
 393
 394     return $self-&gt;{last_name};
 395 }</code></pre>
 396
 397 </div>
 398
 399 <div class="slide">
 400     <h1>Side by side</h1>
 401
 402     <table class="side-by-side">
 403         <tr>
 404           <td>
 405             <pre><code>package Person;
 406 use Moose;
 407
 408 has last_name =&gt; (
 409     is  =&gt; 'rw',
 410     isa =&gt; 'Str',
 411 );</code></pre>
 412             </td>
 413             <td>
 414                 <pre class="small"><code>package Person;
 415 use strict;
 416 use warnings;
 417 use Carp 'confess';
 418
 419 sub new {
 420     my $class = shift;
 421     my %args  = @_;
 422     my $self  = {};
 423
 424     if (exists $args{last_name}) {
 425         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 426                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 427             if ref($args{last_name});
 428         $self-&gt;{last_nane} = $args{last_name};
 429     }
 430
 431     return bless $self, $class;
 432 }
 433
 434 sub last_name {
 435     my $self = shift;
 436
 437     if (@_) {
 438         my $value = shift;
 439         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 440                 . &quot;Validation failed for 'Str' with value $value&quot;
 441             if ref($value);
 442         $self-&gt;{last_name} = $value;
 443     }
 444
 445     return $self-&gt;{last_name};
 446 }</code></pre>
 447             </td>
 448         </tr>
 449     </table>
 450
 451 </div>
 452
 453 <div class="slide">
 454     <h1>Side by side</h1>
 455
 456     <table class="side-by-side">
 457         <tr>
 458             <td>
 459                 <pre><code><span class="match-moose">package Person;</span>
 460 use Moose;
 461
 462 has last_name =&gt; (
 463     is  =&gt; 'rw',
 464     isa =&gt; 'Str',
 465 );</code></pre>
 466             </td>
 467             <td>
 468                 <pre class="small"><code><span class="match-unsweet">package Person;</span>
 469 use strict;
 470 use warnings;
 471 use Carp 'confess';
 472
 473 sub new {
 474     my $class = shift;
 475     my %args  = @_;
 476     my $self  = {};
 477
 478     if (exists $args{last_name}) {
 479         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 480                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 481             if ref($args{last_name});
 482         $self-&gt;{last_nane} = $args{last_name};
 483     }
 484
 485     return bless $self, $class;
 486 }
 487
 488 sub last_name {
 489     my $self = shift;
 490
 491     if (@_) {
 492         my $value = shift;
 493         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 494                 . &quot;Validation failed for 'Str' with value $value&quot;
 495             if ref($value);
 496         $self-&gt;{last_name} = $value;
 497     }
 498
 499     return $self-&gt;{last_name};
 500 }</code></pre>
 501             </td>
 502         </tr>
 503     </table>
 504 </div>
 505
 506 <div class="slide">
 507     <h1>Side by side</h1>
 508
 509     <table class="side-by-side">
 510         <tr>
 511             <td>
 512                 <pre><code>package Person;
 513 <span class="match-moose">use Moose;</span>
 514
 515 has last_name =&gt; (
 516     is  =&gt; 'rw',
 517     isa =&gt; 'Str',
 518 );</code></pre>
 519             </td>
 520             <td>
 521                 <pre class="small"><code>package Person;
 522 <span class="match-unsweet">use strict;
 523 use warnings;
 524 use Carp 'confess';
 525
 526 sub new {
 527     my $class = shift;
 528     my %args  = @_;
 529     my $self  = {};</span>
 530
 531     if (exists $args{last_name}) {
 532         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 533                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 534             if ref($args{last_name});
 535         $self-&gt;{last_nane} = $args{last_name};
 536     }
 537
 538     <span class="match-unsweet">return bless $self, $class;
 539 }</span>
 540
 541 sub last_name {
 542     my $self = shift;
 543
 544     if (@_) {
 545         my $value = shift;
 546         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 547                 . &quot;Validation failed for 'Str' with value $value&quot;
 548             if ref($value);
 549         $self-&gt;{last_name} = $value;
 550     }
 551
 552     return $self-&gt;{last_name};
 553 }</code></pre>
 554             </td>
 555         </tr>
 556     </table>
 557 </div>
 558
 559 <div class="slide">
 560     <h1>Side by side</h1>
 561
 562     <table class="side-by-side">
 563         <tr>
 564             <td>
 565                 <pre><code>package Person;
 566 use Moose;
 567
 568 <span class="match-moose">has last_name =&gt; (</span>
 569     is  =&gt; 'rw',
 570     isa =&gt; 'Str',
 571 <span class="match-moose">);</span></code></pre>
 572             </td>
 573             <td>
 574                 <pre class="small"><code>package Person;
 575 use strict;
 576 use warnings;
 577 use Carp 'confess';
 578
 579 sub new {
 580     my $class = shift;
 581     my %args  = @_;
 582     my $self  = {};
 583
 584     <span class="match-unsweet">if (exists $args{last_name}) {</span>
 585         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 586                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 587             if ref($args{last_name});
 588         <span class="match-unsweet">$self-&gt;{last_nane} = $args{last_name};
 589     }</span>
 590
 591     return bless $self, $class;
 592 }
 593
 594 sub last_name {
 595     my $self = shift;
 596
 597     if (@_) {
 598         my $value = shift;
 599         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 600                 . &quot;Validation failed for 'Str' with value $value&quot;
 601             if ref($value);
 602         $self-&gt;{last_name} = $value;
 603     }
 604
 605     return $self-&gt;{last_name};
 606 }</code></pre>
 607             </td>
 608         </tr>
 609     </table>
 610 </div>
 611
 612 <div class="slide">
 613     <h1>Side by side</h1>
 614
 615     <table class="side-by-side">
 616         <tr>
 617             <td>
 618                 <pre><code>package Person;
 619 use Moose;
 620
 621 has last_name =&gt; (
 622     <span class="match-moose">is  =&gt; 'rw',</span>
 623     isa =&gt; 'Str',
 624 );</code></pre>
 625             </td>
 626             <td>
 627                 <pre class="small"><code>package Person;
 628 use strict;
 629 use warnings;
 630 use Carp 'confess';
 631
 632 sub new {
 633     my $class = shift;
 634     my %args  = @_;
 635     my $self  = {};
 636
 637     if (exists $args{last_name}) {
 638         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 639                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 640             if ref($args{last_name});
 641         $self-&gt;{last_nane} = $args{last_name};
 642     }
 643
 644     return bless $self, $class;
 645 }
 646
 647 <span class="match-unsweet">sub last_name {
 648     my $self = shift;
 649
 650     if (@_) {
 651         my $value = shift;</span>
 652         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 653                 . &quot;Validation failed for 'Str' with value $value&quot;
 654             if ref($value);
 655         <span class="match-unsweet">$self-&gt;{last_name} = $value;
 656     }
 657
 658     return $self-&gt;{last_name};
 659 }</span></code></pre>
 660             </td>
 661         </tr>
 662     </table>
 663 </div>
 664
 665 <div class="slide">
 666     <h1>Side by side</h1>
 667
 668     <table class="side-by-side">
 669         <tr>
 670             <td>
 671                 <pre><code>package Person;
 672 use Moose;
 673
 674 has last_name =&gt; (
 675     is  =&gt; 'rw',
 676     <span class="match-moose">isa =&gt; 'Str',</span>
 677 );</code></pre>
 678             </td>
 679             <td>
 680                 <pre class="small"><code>package Person;
 681 use strict;
 682 use warnings;
 683 use Carp 'confess';
 684
 685 sub new {
 686     my $class = shift;
 687     my %args  = @_;
 688     my $self  = {};
 689
 690     if (exists $args{last_name}) {
 691         <span class="match-unsweet">confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 692                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 693             if ref($args{last_name});</span>
 694         $self-&gt;{last_nane} = $args{last_name};
 695     }
 696
 697     return bless $self, $class;
 698 }
 699
 700 sub last_name {
 701     my $self = shift;
 702
 703     if (@_) {
 704         my $value = shift;
 705         <span class="match-unsweet">confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 706                 . &quot;Validation failed for 'Str' with value $value&quot;
 707             if ref($value);</span>
 708         $self-&gt;{last_name} = $value;
 709     }
 710
 711     return $self-&gt;{last_name};
 712 }</code></pre>
 713             </td>
 714         </tr>
 715     </table>
 716 </div>
 717
 718 <div class="slide">
 719     <h1>Side by side</h1>
 720
 721     <table class="side-by-side">
 722         <tr class="incremental">
 723             <td>5 lines</td>
 724             <td>21 lines</td>
 725         </tr>
 726         <tr class="incremental">
 727             <td>92 characters</td>
 728             <td>741 characters</td>
 729         </tr>
 730         <tr>
 731             <td>
 732                 <pre><code>package Person;
 733 use Moose;
 734
 735 has last_name =&gt; (
 736     is  =&gt; 'rw',
 737     isa =&gt; 'Str',
 738 );</code></pre>
 739             </td>
 740             <td>
 741                 <pre class="small"><code>package Person;
 742 use strict;
 743 use warnings;
 744 use Carp 'confess';
 745
 746 sub new {
 747     my $class = shift;
 748     my %args  = @_;
 749     my $self  = {};
 750
 751     if (exists $args{last_name}) {
 752         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 753                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 754             if ref($args{last_name});
 755         $self-&gt;{last_nane} = $args{last_name};
 756     }
 757
 758     return bless $self, $class;
 759 }
 760
 761 sub last_name {
 762     my $self = shift;
 763
 764     if (@_) {
 765         my $value = shift;
 766         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 767                 . &quot;Validation failed for 'Str' with value $value&quot;
 768             if ref($value);
 769         $self-&gt;{last_name} = $value;
 770     }
 771
 772     return $self-&gt;{last_name};
 773 }</code></pre>
 774             </td>
 775         </tr>
 776     </table>
 777 </div>
 778
 779 <div class="slide">
 780     <h1>Typo?</h1>
 781
 782     <pre class="small"><code>sub new {
 783     my $class = shift;
 784     my %args  = @_;
 785     my $self  = {};
 786
 787     if (exists $args{last_name}) {
 788         confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 789                 . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 790             if ref($args{last_name});
 791         $self-&gt;{last_nane} = $args{last_name};
 792     }
 793
 794     return bless $self, $class;
 795 }</code></pre>
 796 </div>
 797
 798 <div class="slide">
 799     <h1>Typo?</h1>
 800
 801     <pre class="small"><code>if (exists $args{last_name}) {
 802     confess &quot;Attribute (last_name) does not pass the type constraint because: &quot;
 803             . &quot;Validation failed for 'Str' with value $args{last_name}&quot;
 804         if ref($args{last_name});
 805     $self-&gt;{last_nane} = $args{last_name};
 806 }</code></pre>
 807 </div>
 808
 809 <div class="slide">
 810     <h1>Typo?</h1>
 811
 812     <code>$self-&gt;{last_nane} = $args{last_name};</code>
 813 </div>
 814
 815 <div class="slide">
 816     <h1>Typo?</h1>
 817     <code>$self-&gt;{last_na<span class="wrong">n</span>e}</code>
 818 </div>
 819
 820 <div class="slide">
 821     <h1>Why Moose?</h1>
 822
 823     <pre><code>package Person;
 824 use Moose;
 825
 826 has last_name =&gt; (
 827     is  =&gt; 'rw',
 828     isa =&gt; 'Str',
 829 );</code></pre>
 830 </div>
 831
 832 <div class="slide fake-slide0">
 833   <h1>Part 1: Moose Classes</h1>
 834 </div>
 835
 836 <div class="slide">
 837   <h1>Moose Classes</h1>
 838
 839   <ul>
 840     <li>Moose classes are Perl packages which <code>use Moose</code></li>
 841   </ul>
 842 </div>
 843
 844 <div class="slide">
 845   <h1>Moose.pm and Your Class</h1>
 846
 847   <pre><code>package Person;
 848 use Moose;</code></pre>
 849
 850   <ul>
 851     <li><code>Moose.pm</code> provides declarative sugar</li>
 852     <li>Turns on <code>strict</code> and <code>warnings</code></li>
 853     <li>Creates metaclasses for your class: <code>Person-&gt;meta</code></li>
 854     <li>Moose classes automatically inherit from <code>Moose::Object</code></li>
 855   </ul>
 856 </div>
 857
 858 <div class="slide">
 859   <h1>What <code>Moose::Object</code> Provides</h1>
 860
 861   <ul>
 862     <li>Constructor - <code>new()</code></li>
 863     <li>Calls your <code>BUILDARGS()</code> and/or <code>BUILD()</code></li>
 864     <li>Calls your <code>DEMOLISH</code> during object destruction</li>
 865   </ul>
 866 </div>
 867
 868 <div class="slide">
 869   <h1>BUILDARGS</h1>
 870
 871   <ul>
 872     <li>Takes <code>@_</code>, returns a hash reference of attribute names/value</li>
 873     <li>Accepts a hash or hashref; throws otherwise</li>
 874     <li>Provide your own for other cases</li>
 875     <li><strong>Always</strong> call <code>$class-&gt;SUPER::BUILDARGS(@_)</code> as a fallback!</li>
 876   </ul>
 877 </div>
 878
 879 <div class="slide">
 880   <h1>BUILDARGS Example</h1>
 881
 882   <pre><code>package Person;
 883 use Moose;
 884
 885 sub BUILDARGS {
 886     my $class = shift;
 887
 888     if ( @_ == 1 &amp;&amp; ! ref $_[0] ) {
 889         <span class="highlight">return { ssn =&gt; $_[0] };</span>
 890     }
 891
 892     <span class="highlight">return $class-&gt;SUPER::BUILDARGS(@_)</span>;
 893 }
 894
 895 <span class="highlight">Person-&gt;new('123-45-6789')</span></code></pre>
 896 </div>
 897
 898 <div class="slide">
 899   <h1>BUILD</h1>
 900
 901   <ul>
 902     <li>Called after object is created, before <code>new</code> returns</li>
 903     <li>Chance to do more complex validation, set complex attributes</li>
 904     <li>Called in reverse inheritance order, parents to children</li>
 905     <li>Return value is ignored</li>
 906   </ul>
 907 </div>
 908
 909 <div class="slide">
 910   <h1>BUILD Example</h1>
 911
 912   <pre><code>package Person;
 913 use Moose;
 914
 915 sub BUILD {
 916     my $self = shift;
 917
 918     if ( $self-&gt;country_of_residence
 919          eq 'USA' ) {
 920         die 'All US residents'
 921             . ' must have an SSN'
 922             unless $self-&gt;has_ssn;
 923     }
 924 }</code></pre>
 925 </div>
 926
 927 <div class="slide">
 928   <h1>Object Construction a la Moose</h1>
 929
 930   <pre><code>Person-&gt;new(@_)</code></pre>
 931
 932   <ol>
 933     <li>Calls <code>Person-&gt;BUILDARGS(@_)</code> to turn <code>@_</code> into a hashref</li>
 934     <li>Blesses a reference</li>
 935     <li>Populates attributes based on the hashref from #1</li>
 936     <li>Calls <code>$new_object->BUILDALL($constructor_args)</code>
 937         <br />... which calls all <code>BUILD</code> methods</li>
 938     <li>Returns the object</li>
 939   </ol>
 940 </div>
 941
 942 <div class="slide">
 943   <h1>The Object is Opaque</h1>
 944
 945   <ul>
 946     <li>Technically it's a hash reference</li>
 947     <li><span class="wrong">If you <em>ever</em> treat it as one <strong>you are doing it wrong!</strong></span></li>
 948   </ul>
 949 </div>
 950
 951 <div class="slide">
 952   <h1>DEMOLISH</h1>
 953
 954   <ul>
 955     <li>Like <code>DESTROY</code>, but Moose makes sure all <code>DEMOLISH</code> methods in a hierarchy are called</li>
 956     <li>Called in normal inheritance order, children to parents</li>
 957   </ul>
 958 </div>
 959
 960 <div class="slide">
 961   <h1>extends</h1>
 962
 963   <ul>
 964     <li><code>extends</code> is sugar for declaring parent classes</li>
 965   </ul>
 966
 967   <pre><code>package Employee;
 968 use Moose;
 969 <span class="highlight">extends 'Person';</span></code></pre>
 970 </div>
 971
 972 <div class="slide">
 973   <h1>extends</h1>
 974
 975   <ul>
 976     <li>Each call to <code>extends</code> <strong>resets</strong> your parents</li>
 977   </ul>
 978
 979   <h2 class="wrong">Wrong</h2>
 980
 981   <pre><code>package EvilEmployee;
 982 use Moose;
 983 extends 'Person';
 984 extends 'Thief';</code></pre>
 985
 986   <h2 class="right">Right</h2>
 987
 988   <pre><code>package EvilEmployee;
 989 use Moose;
 990 extends 'Person', 'Thief';</code></pre>
 991 </div>
 992
 993 <div class="slide">
 994   <h1>Extending un-Moose-y Parents</h1>
 995
 996   <pre><code>package My::LWP;
 997 use Moose;
 998 extends 'LWP';</code></pre>
 999
1000   <ul>
1001     <li>No <code>Moose::Object</code>, so ...
1002       <ul>
1003         <li>No attribute-handling <code>new()</code></li>
1004         <li>No <code>BUILDARGS()</code> or <code>BUILD()</code></li>
1005         <li>No <code>DEMOLISH()</code></li>
1006       </ul>
1007     </li>
1008     <li>But see <code>MooseX::NonMoose</code> for a workaround</li>
1009   </ul>
1010 </div>
1011
1012 <div class="slide">
1013   <h1><code>override</code> and <code>super</code></h1>
1014
1015   <ul>
1016     <li><code>override</code> is another method modifier</li>
1017     <li>An alternative to Perl's <code>SUPER::</code></li>
1018   </ul>
1019 </div>
1020
1021 <div class="slide">
1022   <h1><code>override</code> and <code>super</code></h1>
1023
1024   <pre><code>package Employee;
1025 use Moose;
1026
1027 <span class="current incremental">extends 'Person';</span>
1028
1029 <span class="incremental">override</span> work =&gt; sub {
1030     my $self = shift;
1031
1032     die "Pay me first" unless $self-&gt;got_paid;
1033     <span class="incremental">super();</span>
1034 }<span class="incremental">;</span></code></pre>
1035 </div>
1036
1037 <div class="slide">
1038   <h1>Caveat <code>super</code></h1>
1039
1040   <ul>
1041     <li>Mostly like <code>$self-&gt;SUPER::work(@_)</code></li>
1042     <li><strong>But</strong> cannot change <code>@_</code>!</li>
1043     <li>Binds the parent's method at compile time</li>
1044   </ul>
1045 </div>
1046
1047 <div class="slide">
1048   <h1>Minimal Attributes</h1>
1049
1050   <ul>
1051     <li><code>has 'foo'</code></li>
1052     <li>Use <code>is =&gt; 'ro'</code> or <code>is =&gt; 'rw'</code></li>
1053     <li>Attributes without "is" have no accessors</li>
1054   </ul>
1055 </div>
1056
1057 <div class="slide">
1058   <h1>Read-write attributes</h1>
1059
1060   <pre><code>package Person;
1061 use Moose;
1062
1063 has first_name =&gt; ( <span class="highlight">is =&gt; 'rw'</span> );
1064
1065 my $person =
1066     Person-&gt;new( first_name =&gt; 'Dave' );
1067
1068 $person-&gt;first_name('Stevan');
1069 print $person-&gt;first_name; # Stevan</code></pre>
1070
1071 </div>
1072
1073 <div class="slide">
1074   <h1>Read-only attributes</h1>
1075
1076   <pre><code>package Person;
1077 use Moose;
1078
1079 has first_name =&gt; ( <span class="highlight">is =&gt; 'ro'</span> );
1080
1081 my $person =
1082     Person-&gt;new( first_name =&gt; 'Dave' );
1083
1084 $person-&gt;first_name('Stevan');
1085 print $person-&gt;first_name; # Dave</code></pre>
1086
1087 </div>
1088
1089 <div class="slide">
1090   <h1>There is More to Come</h1>
1091
1092   <ul>
1093     <li>Attributes have a <em>lot</em> of features</li>
1094   </ul>
1095 </div>
1096
1097 <div class="slide">
1098   <h1>Cleaning Up Moose Droppings</h1>
1099
1100   <pre><code>package Person;
1101 use Moose;
1102
1103 # true
1104 Person->can('extends');</code></pre>
1105
1106   <ul>
1107     <li>Not very hygienic</li>
1108   </ul>
1109 </div>
1110
1111 <div class="slide">
1112   <h1>Cleaning Up Moose Droppings</h1>
1113
1114   <pre><code>package Person;
1115 use Moose;
1116
1117 ...
1118
1119 no Moose;
1120
1121 # false
1122 Person->can('extends');</code></pre>
1123 </div>
1124
1125 <div class="slide">
1126   <h1>No Moose</h1>
1127
1128   <ul>
1129     <li><code>no Moose</code> at the end of a package is a best practice</li>
1130     <li>Or <code>namespace::clean</code> at the top</li>
1131     <li>Just do it</li>
1132   </ul>
1133 </div>
1134
1135 <div class="slide">
1136   <h1>Immutability</h1>
1137
1138   <ul>
1139     <li><span style="font-family: URW Chancery L; font-size: 140%">Stevan's Incantation of Fleet-Footedness</span></li>
1140   </ul>
1141
1142   <pre><code>package Person;
1143 use Moose;
1144
1145 <span class="highlight">__PACKAGE__->meta->make_immutable;</span></code></pre>
1146 </div>
1147
1148 <div class="slide">
1149   <h1>What <code>make_immutable</code> does</h1>
1150
1151   <ul>
1152     <li>Magic</li>
1153     <li>Uses <code>eval</code> to "inline" a constructor</li>
1154     <li>Memoizes a lot of meta-information</li>
1155     <li>Makes loading your class slower</li>
1156     <li>Makes object creation <em>much</em> faster</li>
1157   </ul>
1158 </div>
1159
1160 <div class="slide">
1161   <h1>When to Immutabilize?</h1>
1162
1163   <ul>
1164     <li><em>Almost</em> always</li>
1165     <li>Startup time vs execution time</li>
1166   </ul>
1167 </div>
1168
1169 <div class="slide">
1170   <h1>Classes Summary</h1>
1171
1172   <ul>
1173     <li><code>use Moose</code></li>
1174     <li><code>Class-&gt;meta</code></li>
1175     <li><code>Moose::Object</code> base class</li>
1176     <li><code>extends</code>, <code>override</code>, and <code>super</code></li>
1177     <li>Simple attributes: <code>has</code>, <code>is&nbsp;=&gt;&nbsp;'ro'</code>, &amp; <code>is&nbsp;=&gt;&nbsp;'rw'</code></li>
1178     <li><code>no Moose</code></li>
1179     <li><code>__PACKAGE__-&gt;meta-&gt;make_immutable</code></li>
1180   </ul>
1181 </div>
1182
1183 <div class="slide">
1184   <h1>Questions?</h1>
1185 </div>
1186
1187 <div class="slide">
1188   <h1>Exercises</h1>
1189
1190   <pre># cd exercises
1191
1192 # perl bin/prove -lv t/00-prereq.t
1193
1194 # perl install-moose (if needed)
1195
1196 # perl bin/prove -lv t/01-classes.t
1197
1198 # edit lib/Person.pm and lib/Employee.pm
1199
1200 Iterate til this passes all its tests</pre>
1201 </div>
1202
1203 <div class="slide fake-slide0">
1204   <h1>Part 2: Roles</h1>
1205 </div>
1206
1207 <div class="slide">
1208   <h1>Just What Is a Role?</h1>
1209
1210   <ul>
1211     <li>Mixin? Interface? Trait?</li>
1212     <li>Yes ... and more!</li>
1213   </ul>
1214 </div>
1215
1216 <div class="slide">
1217   <h1>Roles Can Have State <strong>and</strong> Behavior</h1>
1218
1219   <pre><code>package HasPermissions;
1220 use Moose::Role;
1221
1222 <span class="current incremental"># state
1223 has access_level =&gt; ( is =&gt; 'rw' );</span>
1224
1225 <span class="incremental"># behavior
1226 sub can_access {
1227     my $self     = shift;
1228     my $required = shift;
1229
1230     return $self-&gt;access_level &gt;= $required;
1231 }</span></code></pre>
1232
1233 </div>
1234
1235 <div class="slide">
1236   <h1>Roles Can Define Interfaces</h1>
1237
1238   <pre><code>package Printable;
1239 use Moose::Role;
1240
1241 requires 'as_string';</code></pre>
1242 </div>
1243
1244 <div class="slide">
1245   <h1>Roles Can Do All Three</h1>
1246
1247   <pre><code>package Printable;
1248 use Moose::Role;
1249
1250 requires 'as_string';
1251
1252 has has_been_printed =&gt; ( is =&gt; 'rw'  );
1253
1254 sub print {
1255     my $self = shift;
1256     print $self-&gt;as_string;
1257     $self-&gt;has_been_printed(1);
1258 }</code></pre>
1259 </div>
1260
1261 <div class="slide">
1262   <h1>Classes Consume Roles</h1>
1263
1264   <pre><code>package Person;
1265 use Moose;
1266
1267 with 'HasPermissions';</code></pre>
1268 </div>
1269
1270 <div class="slide">
1271   <h1>Classes Consume Roles</h1>
1272
1273 <pre><code>my $person = Person-&gt;new(
1274     first_name => 'Kenichi',
1275     last_name => 'Asai',
1276     access_level =&gt; 42,
1277 );
1278
1279 print $person-&gt;full_name
1280     . ' has '
1281     . $person-&gt;can_access(42)
1282         ? 'great power'
1283         : 'little power';</code></pre>
1284 </div>
1285
1286 <div class="slide">
1287   <h1>Roles in Practice</h1>
1288
1289   <ul>
1290     <li>Consuming a role =~ inlining the role</li>
1291   </ul>
1292 </div>
1293
1294 <div class="slide">
1295   <h1>In Other Words ...</h1>
1296
1297 <pre><code>package Person;
1298 use Moose;
1299
1300 <span class="highlight">with 'Printable';</span></code></pre>
1301 </div>
1302
1303 <div class="slide">
1304   <h1>In Other Words ...</h1>
1305
1306 <pre><code>package Person;
1307 use Moose;
1308
1309 <span class="delete">with 'Printable';</span>
1310
1311 <span class="highlight">has has_been_printed =&gt; ( is =&gt; 'rw'  );
1312
1313 sub print {
1314     my $self = shift;
1315     print $self-&gt;as_string;
1316     $self-&gt;has_been_printed(1);
1317 }</span></code></pre>
1318 </div>
1319
1320 <div class="slide">
1321   <h1>Except</h1>
1322
1323   <ul>
1324     <li>Role consumption is introspectable</li>
1325   </ul>
1326
1327   <pre><code>if ( Person-&gt;does('Printable') ) { ... }
1328
1329 # or ...
1330
1331 if ( Person-&gt;meta-&gt;does('Printable') ) { ... }</code></pre>
1332
1333 </div>
1334
1335 <div class="slide">
1336   <h1>These Names Are the Same</h1>
1337
1338   <ul>
1339     <li>What if a role and class define the same method?</li>
1340     <li>A class's <em>local</em> methods win over the role's</li>
1341     <li>The role's methods win over the class's <em>inherited</em> methods</li>
1342   </ul>
1343 </div>
1344
1345 <div class="slide">
1346   <h1>Conflicts Between Roles</h1>
1347
1348   <ul>
1349     <li>Two roles with a method of the same name</li>
1350     <li>Generates a compile-time error when consumed by a class</li>
1351   </ul>
1352 </div>
1353
1354 <div class="slide">
1355   <h1>Conflict Example</h1>
1356
1357   <pre><code>package IsFragile;
1358 use Moose::Role;
1359
1360 sub break { ... }
1361
1362 package CanBreakdance;
1363 use Moose::Role;
1364
1365 sub break { ... }</code></pre>
1366 </div>
1367
1368 <div class="slide">
1369   <h1>Conflict Example</h1>
1370
1371   <pre><code>package FragileDancer;
1372 use Moose;
1373
1374 <span class="highlight">with 'IsFragile', 'CanBreakdance';</span></code></pre>
1375
1376   <ul>
1377     <li>Only one <code>with</code>!</li>
1378   </ul>
1379 </div>
1380
1381 <div class="slide">
1382   <h1>Conflict Resolution</h1>
1383
1384   <ul>
1385     <li>The consuming class must resolve the conflict by implementing the method</li>
1386     <li>Can use some combination of method exclusion and aliasing</li>
1387   </ul>
1388 </div>
1389
1390 <div class="slide">
1391   <h1>Method Aliasing</h1>
1392
1393   <pre><code>package FragileDancer;
1394 use Moose;
1395
1396 <span class="highlight">with 'IsFragile' =>
1397          { alias =>
1398                { break => 'break_bone' } },
1399      'CanBreakdance' =>
1400          { alias =>
1401                { break => 'break_it_down' } };</span></code></pre>
1402
1403   <ul>
1404     <li>Renames the roles' methods</li>
1405     <li>Still conflicts, need to <code>exclude</code> as well</li>
1406   </ul>
1407 </div>
1408
1409 <div class="slide">
1410   <h1>Method Exclusion</h1>
1411
1412   <pre><code>package FragileDancer;
1413 use Moose;
1414
1415 <span class="highlight">with 'IsFragile' =>
1416          { alias =>
1417                { break => 'break_bone' },
1418            exclude => 'break' },
1419      'CanBreakdance' =>
1420          { alias =>
1421                { break => 'break_dance' },
1422            exclude => 'break' };</span></code></pre>
1423 </div>
1424
1425 <div class="slide">
1426   <h1>And then ...</h1>
1427
1428   <pre><code>package FragileDancer;
1429 use Moose;
1430
1431 sub break {
1432     my $self = shift;
1433
1434     $self->break_dance;
1435     if ( rand(1) &lt; 0.5 ) {
1436         $self->break_bone;
1437     }
1438 }</code></pre>
1439 </div>
1440
1441 <div class="slide">
1442   <h1>Still Full of Fail</h1>
1443
1444   <ul>
1445     <li>Roles are also about semantics!</li>
1446     <li>We've fulfilled the letter and lost the spirit</li>
1447     <li>Roles have a <em>meaning</em></li>
1448     <li>Think twice before blindly aliasing and excluding methods!</li>
1449   </ul>
1450 </div>
1451
1452 <div class="slide">
1453   <h1>Hot Role-on-Role Action</h1>
1454
1455   <pre><code>package Comparable;
1456 use Moose::Role;
1457
1458 requires 'compare';</code></pre>
1459 </div>
1460
1461 <div class="slide">
1462   <h1>Hot Role-on-Role Action</h1>
1463
1464   <pre><code>package TestsEquality;
1465 use Moose::Role;
1466
1467 with 'Comparable';
1468
1469 sub is_equal {
1470     my $self = shift;
1471     return $self->compare(@_) == 0;
1472 }</code></pre>
1473 </div>
1474
1475 <div class="slide">
1476   <h1>And then ...</h1>
1477
1478   <pre><code>package Integer;
1479 use Moose;
1480
1481 with 'TestsEquality';
1482
1483 # Satisfies the Comparable role
1484 sub compare { ... }
1485
1486 Integer->does('TestsEquality'); # true
1487 Integer->does('Comparable'); # also true!</code></pre>
1488 </div>
1489
1490 <div class="slide">
1491   <h1>Name Conflicts Between Roles</h1>
1492
1493   <pre><code>package HasSubProcess;
1494 use Moose::Role;
1495
1496 <span class="highlight">sub execute { ... }</span>
1497
1498 package Killer;
1499 use Moose::Role;
1500
1501 with 'HasSubProcess';
1502
1503 <span class="highlight">sub execute { ... }</span></code></pre>
1504 </div>
1505
1506 <div class="slide">
1507   <h1>Delayed Conflict</h1>
1508
1509   <pre><code>package StateOfTexas;
1510 with 'Killer';</code></pre>
1511
1512   <ul>
1513     <li><code>StateOfTexas</code> must implement its own <code>execute</code></li>
1514     <li>But loading the <code>Killer</code> role by itself does not cause an error</li>
1515   </ul>
1516 </div>
1517
1518 <div class="slide">
1519   <h1>Roles as Interfaces</h1>
1520
1521   <ul>
1522     <li>Roles can <code>require</code> methods of their consumers</li>
1523     <li>Compile-time checks</li>
1524     <li>Method must exist when the role is consumed</li>
1525   </ul>
1526 </div>
1527
1528 <div class="slide">
1529   <h1>The Attribute Gotcha</h1>
1530
1531 <pre><code>package HasSize;
1532 use Moose::Role;
1533
1534 <span class="current incremental">requires 'size';</span>
1535
1536 package Shirt;
1537 use Moose;
1538
1539 <span class="incremental">with 'HasSize';
1540
1541 has size => ( is => 'ro' );</span></code></pre>
1542 </div>
1543
1544 <div class="slide">
1545   <h1>The Attribute Gotcha Workaround</h1>
1546
1547   <pre><code>package HasSize;
1548 use Moose::Role;
1549
1550 requires 'size';
1551
1552 package Shirt;
1553 use Moose;
1554
1555 has size => ( is => 'ro' );
1556
1557 with 'HasSize';</code></pre>
1558 </div>
1559
1560 <div class="slide">
1561   <h1>Compile-time Is a Lie</h1>
1562
1563   <ul>
1564     <li>Really, it's <em>package load</em> time</li>
1565     <li>That's run-time, but before the "real" run-time</li>
1566     <li>Moose does not rewire Perl, it's just sugar!</li>
1567     <li>(but <code>MooseX::Declare</code> <em>does</em> rewire Perl)</li>
1568   </ul>
1569 </div>
1570
1571 <div class="slide">
1572   <h1>Enforcing Roles</h1>
1573
1574   <pre><code>package Comparison;
1575 use Moose;
1576
1577 has [ 'left', 'right' ] => (
1578     is   => 'ro',
1579     <span class="highlight">does => 'Comparable',</span>
1580 );
1581 </code></pre>
1582
1583   <ul>
1584     <li>A sneak peek at type constraints</li>
1585   </ul>
1586 </div>
1587
1588
1589 <div class="slide">
1590   <h1>Roles Can Be Applied to Objects</h1>
1591
1592   <pre><code>use Moose::Util qw( apply_all_roles );
1593
1594 my $fragile_person = Person->new( ... );
1595 apply_all_roles( $fragile_person, 'IsFragile' );</code></pre>
1596
1597   <ul>
1598     <li>Does not change the <code>Person</code> class</li>
1599     <li>Works with non-Moose classes, great for monkey-patching!</li>
1600   </ul>
1601 </div>
1602
1603 <div class="slide">
1604   <h1>Roles Are Dirty Too</h1>
1605
1606   <ul>
1607     <li>Once again, clean up those Moose droppings</li>
1608   </ul>
1609
1610   <pre><code>package Comparable;
1611 use Moose::Role;
1612
1613 requires 'compare';
1614
1615 <span class="highlight">no Moose::Role;</span></code></pre>
1616
1617   <ul>
1618     <li>But roles cannot be made immutable</li>
1619   </ul>
1620 </div>
1621
1622 <div class="slide">
1623   <h1>The Zen of Roles</h1>
1624
1625   <ul>
1626     <li>Roles represent discrete units of ...
1627       <ul>
1628         <li>state</li>
1629         <li>behavior</li>
1630         <li>interface</li>
1631       </ul>
1632     </li>
1633     <li>Roles are shareable between unrelated classes</li>
1634     <li>Roles are what a class <em>does</em>, not what it <em>is</em></li>
1635     <li>Roles <em>add</em> functionality, inheritance <em>specializes</em></li>
1636   </ul>
1637 </div>
1638
1639 <div class="slide">
1640   <h1>Abstract Examples</h1>
1641
1642   <ul>
1643     <li>Human <em>@ISA</em> Animal</li>
1644     <li>Human <em>does</em> Toolmaker (as <em>does</em> Chimpanzee)</li>
1645     <li>Car <em>@ISA</em> Vehicle</li>
1646     <li>Car <em>does</em> HasEngine</li>
1647   </ul>
1648 </div>
1649
1650 <div class="slide">
1651   <h1>Real Examples</h1>
1652
1653   <ul>
1654     <li>Objects representing SQL database components and queries
1655       <ul>
1656         <li>Schema, Table, Column, ColumnAlias</li>
1657         <li>Select, Insert, Update, Delete</li>
1658       </ul>
1659     </li>
1660   </ul>
1661 </div>
1662
1663 <div class="slide">
1664   <h1>Real Examples</h1>
1665
1666   <ul>
1667     <li>Column and ColumnAlias both <em>do</em> ColumnLike</li>
1668     <li>ColumnLike things can be used in certain parts of queries</li>
1669     <li>All queries <em>do</em> HasWhereClause</li>
1670     <li>Select <em>does</em> Comparable and Selectable (for subselects)</li>
1671     <li>A where clause requires its components to <em>do</em> Comparable</li>
1672   </ul>
1673 </div>
1674
1675 <div class="slide">
1676   <h1>Roles Summary</h1>
1677
1678   <ul>
1679     <li>Roles can define an interface with <code>requires</code></li>
1680     <li>Roles can have state (attributes) and behavior (methods)</li>
1681     <li>Roles can mix interface, state, &amp; behavior</li>
1682     <li>Roles are composed (flattened) into classes</li>
1683     <li>Roles can do other roles</li>
1684     <li>Roles can be used as a type in APIs (must do Comparable)</li>
1685   </ul>
1686 </div>
1687
1688 <div class="slide">
1689   <h1>Questions?</h1>
1690 </div>
1691
1692 <div class="slide">
1693   <h1>Exercises</h1>
1694
1695   <pre># cd exercises
1696 # perl bin/prove -lv t/02-roles.t
1697
1698 Iterate til this passes all its tests</pre>
1699 </div>
1700
1701 <div class="slide fake-slide0">
1702   <h1>Part 3: Basic Attributes</h1>
1703 </div>
1704
1705 <div class="slide">
1706   <h1>Attributes Are Huge</h1>
1707
1708   <ul>
1709     <li>Moose's biggest feature</li>
1710     <li>The target of <em>many</em> MooseX modules</li>
1711   </ul>
1712 </div>
1713
1714 <div class="slide">
1715   <h1>Quick Review</h1>
1716
1717   <ul>
1718     <li>Declared with <code>has</code></li>
1719     <li>Read-only or read-write</li>
1720   </ul>
1721
1722   <pre><code>package Shirt;
1723 use Moose;
1724
1725 has 'color'     =&gt; ( is =&gt; 'ro' );
1726 has 'is_ripped' =&gt; ( is =&gt; 'rw' );</code></pre>
1727 </div>
1728
1729 <div class="slide">
1730   <h1>Required-ness</h1>
1731
1732   <ul>
1733     <li>Required means "must be passed to the constructor"</li>
1734     <li>But can be <code>undef</code></li>
1735   </ul>
1736 </div>
1737
1738 <div class="slide">
1739   <h1>Required-ness</h1>
1740
1741   <pre><code>package Person;
1742 use Moose;
1743
1744 has first_name =&gt; (
1745     is       =&gt; 'ro',
1746     <span class="current incremental">required =&gt; 1,</span>
1747 );
1748
1749 <span class="incremental">Person->new( first_name =&gt; undef ); # ok
1750 Person->new(); # kaboom</span></code></pre>
1751 </div>
1752
1753 <div class="slide">
1754   <h1>Default and Builder</h1>
1755
1756   <ul>
1757     <li>Attributes can have defaults</li>
1758     <li>Simple non-referecne scalars (number, string)</li>
1759     <li>Subroutine reference</li>
1760     <li>A builder method</li>
1761   </ul>
1762 </div>
1763
1764 <div class="slide">
1765   <h1>Default</h1>
1766
1767   <ul>
1768     <li>Can be a non-reference scalar (including <code>undef</code>)</li>
1769   </ul>
1770
1771   <pre><code>package Person;
1772 use Moose;
1773
1774 has bank =&gt; (
1775     is      =&gt; 'rw',
1776     default =&gt; 'Spire FCU',
1777 );</code></pre>
1778 </div>
1779
1780 <div class="slide">
1781   <h1>Default</h1>
1782
1783   <ul>
1784     <li>Can be a subroutine reference</li>
1785   </ul>
1786
1787   <pre><code>package Person;
1788 use Moose;
1789
1790 has bank =&gt; (
1791     is      =&gt; 'rw',
1792     default =&gt;
1793         sub { Bank-&gt;new(
1794                   name =&gt; 'Spire FCU' ) },
1795 );</code></pre>
1796 </div>
1797
1798 <div class="slide">
1799   <h1>Default as a Subroutine Reference</h1>
1800
1801   <ul>
1802     <li>Called as a method on the object</li>
1803     <li>Called anew for each object</li>
1804   </ul>
1805 </div>
1806
1807 <div class="slide">
1808   <h1>Why No Other Reference Types?</h1>
1809
1810   <pre><code>package Person;
1811 use Moose;
1812
1813 has bank =&gt; (
1814     is      =&gt; 'rw',
1815     <span class="wrong">default =&gt; Bank-&gt;new(
1816                    name =&gt; 'Spire FCU' ),</span>
1817 );</code></pre>
1818
1819   <ul>
1820     <li>Now <strong>every</strong> person shares the <strong>same</strong> Bank object!</li>
1821   </ul>
1822 </div>
1823
1824 <div class="slide">
1825      <h1>Defaulting to an Empty Reference</h1>
1826
1827   <pre><code>package Person;
1828 use Moose;
1829
1830 has packages =&gt; (
1831     is      =&gt; 'rw',
1832     default =&gt; <span class="highlight">sub { [] }</span>,
1833 );</code></pre>
1834 </div>
1835
1836 <div class="slide">
1837   <h1>What if I Want to Share?</h1>
1838
1839   <pre><code>package Person;
1840 use Moose;
1841
1842 my $highlander_bank =
1843     Bank-&gt;new( name =&gt; 'Spire FCU' );
1844
1845 has bank =&gt; (
1846     is      =&gt; 'rw',
1847     default =&gt; sub { $highlander_bank },
1848 );</code></pre>
1849 </div>
1850
1851 <div class="slide">
1852   <h1>Builder</h1>
1853
1854   <ul>
1855     <li>A method <em>name</em> which returns the default</li>
1856   </ul>
1857 </div>
1858
1859 <div class="slide">
1860   <h1>Builder</h1>
1861
1862   <pre><code>package Person;
1863 use Moose;
1864
1865 has bank =&gt; (
1866     is      =&gt; 'rw',
1867     builder =&gt; '_build_bank',
1868 );
1869
1870 sub _build_bank {
1871     my $self = shift;
1872     return Bank-&gt;new( name => 'Spire FCU' );
1873 }</code></pre>
1874 </div>
1875
1876 <div class="slide">
1877   <h1>Default vs Builder</h1>
1878
1879   <ul>
1880     <li>Use default for simple scalars</li>
1881     <li>Use default to return empty references</li>
1882     <li>Use default for <em>very</em> trivial subroutine references</li>
1883     <li>Use builder for everything else</li>
1884   </ul>
1885 </div>
1886
1887 <div class="slide">
1888   <h1>Builder Bonuses</h1>
1889
1890   <ul>
1891     <li>Can be overridden and method modified, because it's called by <em>name</em></li>
1892     <li>Roles can require a builder</li>
1893   </ul>
1894 </div>
1895
1896 <div class="slide">
1897   <h1>Role Requires Builder</h1>
1898
1899   <pre><code>package HasBank;
1900 use Moose::Role;
1901
1902 requires '_build_bank';
1903
1904 has bank =&gt; (
1905     is      =&gt; 'ro',
1906     builder =&gt; '_build_bank',
1907 );</code></pre>
1908 </div>
1909
1910 <div class="slide">
1911   <h1>Lazy, Good for Nothing Attributes</h1>
1912
1913   <ul>
1914     <li>Normally, defaults are generated during object construction</li>
1915     <li>This can be expensive</li>
1916     <li>We want to default to <code>$self-&gt;size * 2</code>, but attribute initialization order is unpredictable</li>
1917     <li>Use lazy attributes!</li>
1918   </ul>
1919 </div>
1920
1921 <div class="slide">
1922   <h1>The Power of Dynamic Defaults</h1>
1923
1924   <pre><code>package Person;
1925 use Moose;
1926
1927 has shoe_size =&gt; (
1928     is =&gt; 'ro',
1929 );</code></pre>
1930 </div>
1931
1932 <div class="slide">
1933   <h1>The Power of Dynamic Defaults</h1>
1934
1935   <pre><code>has shoes =&gt; (
1936     is      =&gt; 'ro',
1937     <span class="highlight">lazy    =&gt; 1,</span>
1938     builder => '_build_shoes',
1939 );
1940
1941 sub _build_shoes {
1942     my $self = shift;
1943
1944     return Shoes-&gt;new(
1945         size =&gt; <span class="highlight">$self-&gt;shoe_size</span> );
1946 }</code></pre>
1947 </div>
1948
1949 <div class="slide">
1950   <h1>Lazy is Good</h1>
1951
1952   <ul>
1953     <li>Lazy defaults are executed when the attribute is read</li>
1954     <li>Can see other object attributes</li>
1955     <li>Still need to watch out for circular laziness</li>
1956   </ul>
1957 </div>
1958
1959 <div class="slide">
1960   <h1>Clearer and Predicate</h1>
1961
1962   <ul>
1963     <li>Attributes can have a value, including <code>undef</code>, or not</li>
1964     <li>Can clear the value with a clearer method</li>
1965     <li>Can check for the existence of a value with a predicate method</li>
1966     <li>By default, these methods are not created</li>
1967   </ul>
1968 </div>
1969
1970 <div class="slide">
1971   <h1>Clearer and Predicate</h1>
1972
1973   <pre><code>package Person;
1974 use Moose;
1975
1976 has account =&gt; (
1977     is        =&gt; 'ro',
1978     lazy      =&gt; 1,
1979     builder   =&gt; '_build_account',
1980     <span class="highlight">clearer   =&gt; '_clear_account',
1981     predicate =&gt; 'has_account',</span>
1982 );</code></pre>
1983 </div>
1984
1985 <div class="slide">
1986   <h1>Clearer and Lazy Defaults</h1>
1987
1988   <ul>
1989     <li>Lazy defaults are good for computed attributes</li>
1990     <li>Clear the attribute when the source data changes</li>
1991     <li>Recalculated at next access</li>
1992   </ul>
1993 </div>
1994
1995 <div class="slide">
1996   <h1>Renaming constructor arguments</h1>
1997
1998   <ul>
1999     <li>By default, constructor names = attribute names</li>
2000     <li>Use <code>init_arg</code> to change this</li>
2001     <li>Set <code>init_arg =&gt; undef</code> to make it unconstructable</li>
2002   </ul>
2003 </div>
2004
2005 <div class="slide">
2006   <h1>Some <code>init_arg</code> examples</h1>
2007
2008   <pre><code>package Person;
2009 use Moose;
2010
2011 has shoe_size => (
2012     is       =&gt; 'ro',
2013     <span class="highlight">init_arg =&gt; 'foot_size',</span>
2014 );
2015
2016 Person->new( <span class="wrong">shoe_size =&gt; 13</span> );
2017
2018 my $person =
2019     Person->new( <span class="right">foot_size =&gt; 13</span> );
2020 print $person->shoe_size;</code></pre>
2021 </div>
2022
2023 <div class="slide">
2024   <h1>Some <code>init_arg</code> examples</h1>
2025
2026 <pre><code>package Person;
2027 use Moose;
2028
2029 has shoes => (
2030     is       =&gt; 'ro',
2031     <span class="highlight">init_arg =&gt; undef,</span>
2032 );
2033
2034 Person->new( <span class="wrong">shoes =&gt; Shoes-&gt;new</span> );</code></pre>
2035 </div>
2036
2037 <div class="slide">
2038   <h1>Why Set <code>init_arg =&gt; undef</code>?</h1>
2039
2040   <ul>
2041     <li>Use this with a lazy default for attributes-as-cache</li>
2042     <li>Compute the value as needed</li>
2043     <li>Ensure that it is always generated correctly (not set by constructor)</li>
2044     <li>Use triggers or method modifiers (coming soon) to clear the value</li>
2045   </ul>
2046 </div>
2047
2048 <div class="slide">
2049   <h1>Attribute Inheritance</h1>
2050
2051   <ul>
2052     <li>By default, subclasses inherit attribute as-is</li>
2053     <li>Can change some attribute parameters in subclasses
2054       <ul>
2055         <li>default</li>
2056         <li>builder</li>
2057         <li>required</li>
2058         <li>lazy</li>
2059         <li>others we've not yet covered</li>
2060       </ul>
2061     </li>
2062   </ul>
2063 </div>
2064
2065 <div class="slide">
2066   <h1>Attribute Inheritance Example</h1>
2067
2068   <pre><code>package Employee;
2069 use Moose;
2070
2071 extends 'Person';
2072
2073 has '<span class="highlight">+first_name</span>' =&gt; (
2074     default =&gt; 'Joe',
2075 );</code></pre>
2076 </div>
2077
2078 <div class="slide">
2079   <h1>Attribute Inheritance Warning</h1>
2080
2081   <ul>
2082     <li>An attribute is a contract about a class's API</li>
2083     <li>Don't break that contract in a subclass</li>
2084     <li>Especially important in the context of types</li>
2085   </ul>
2086 </div>
2087
2088 <div class="slide">
2089   <h1>Changing Accessor Names</h1>
2090
2091   <pre><code>package Person;
2092 use Moose;
2093
2094 has first_name =&gt; (
2095     <span class="highlight">accessor</span> =&gt; 'first_name',
2096 );</code></pre>
2097
2098   <ul>
2099     <li>The long-hand version of <code>is =&gt; 'rw'</code></li>
2100   </ul>
2101 </div>
2102
2103 <div class="slide">
2104   <h1>Changing Accessor Names</h1>
2105
2106   <pre><code>package Person;
2107 use Moose;
2108
2109 has first_name =&gt; (
2110     <span class="highlight">reader</span> =&gt; 'first_name',
2111     <span class="highlight">writer</span> =&gt; undef,
2112 );</code></pre>
2113
2114   <ul>
2115     <li>The long-hand version of <code>is =&gt; 'ro'</code></li>
2116   </ul>
2117 </div>
2118
2119
2120 <div class="slide">
2121   <h1>Changing Accessor Names</h1>
2122
2123   <pre><code>package Person;
2124 use Moose;
2125
2126 has first_name =&gt; (
2127     <span class="highlight">reader</span> =&gt; 'get_first_name',
2128     <span class="highlight">writer</span> =&gt; 'set_first_name',
2129 );</code></pre>
2130 </div>
2131
2132 <div class="slide">
2133   <h1>Changing Accessor Names</h1>
2134
2135   <pre><code>package Person;
2136 use Moose;
2137
2138 has first_name =&gt; (
2139     <span class="highlight">is</span>     =&gt; 'rw',
2140     <span class="highlight">writer</span> =&gt; '_first_name',
2141 );</code></pre>
2142
2143   <ul>
2144     <li>Can also mix-and-match <code>is</code> and explicit names</li>
2145   </ul>
2146 </div>
2147
2148 <div class="slide">
2149   <h1>ETOOMUCHTYPING</h1>
2150
2151   <ul>
2152     <li><code>MooseX::FollowPBP</code><br /><code>get_foo</code> and <code>set_foo</code></li>
2153     <li><code>MooseX::SemiAffordanceAccessor</code><br /><code>foo</code> and <code>set_foo</code></li>
2154   </ul>
2155 </div>
2156
2157 <div class="slide">
2158   <h1>ETOOMUCHTYPING</h1>
2159
2160   <pre><code>package Person;
2161 use Moose;
2162 <span class="highlight">use MooseX::SemiAffordanceAccessor;</span>
2163
2164 has first_name =&gt; (
2165     is =&gt; 'rw',
2166 );</code></pre>
2167
2168   <ul>
2169     <li>Creates <code>first_name</code> and <code>set_first_name</code></li>
2170   </ul>
2171 </div>
2172
2173 <div class="slide">
2174   <h1>Basic Attributes Summary</h1>
2175
2176   <ul>
2177     <li>Attributes can be <code>required</code></li>
2178     <li>Attributes can have a <code>default</code> or <code>builder</code></li>
2179     <li>Attributes with a default or builder can be <code>lazy</code></li>
2180     <li>Attributes can have a <code>clearer</code> and/or <code>predicate</code></li>
2181     <li>An attribute's constructor name can be changed with <code>init_arg</code></li>
2182     <li>A subclass can alter its parents' attributes</li>
2183     <li>Attribute accessor names can be changed</li>
2184   </ul>
2185 </div>
2186
2187 <div class="slide">
2188   <h1>Questions?</h1>
2189 </div>
2190
2191 <div class="slide">
2192   <h1>Exercises</h1>
2193
2194   <pre># cd exercises
2195 # perl bin/prove -lv t/03-basic-attributes.t
2196
2197 Iterate til this passes all its tests</pre>
2198 </div>
2199
2200 <div class="slide fake-slide0">
2201   <h1>Part 4: Method Modifiers</h1>
2202 </div>
2203
2204 <div class="slide">
2205   <h1>What is a Method Modifier</h1>
2206
2207   <ul>
2208     <li>Apply to an existing method</li>
2209     <li>... from a parent class, the current class, or a role</li>
2210     <li>Roles can provide modifiers that are applied at composition time</li>
2211   </ul>
2212 </div>
2213
2214 <div class="slide">
2215   <h1>What is a Method Modifier</h1>
2216
2217   <ul>
2218     <li>"Inject" behavior</li>
2219     <li>Add behavior to generated methods (accessors, delegations)</li>
2220     <li>Provide roles which modify existing behavior</li>
2221   </ul>
2222 </div>
2223
2224 <div class="slide">
2225   <h1>Before and After</h1>
2226
2227   <ul>
2228     <li>Simplest modifiers - <code>before</code> and <code>after</code></li>
2229     <li>Guess when they run!</li>
2230   </ul>
2231 </div>
2232
2233 <div class="slide">
2234   <h1>Uses for <code>before</code></h1>
2235
2236   <ul>
2237     <li>As a pre-call check</li>
2238   </ul>
2239
2240   <pre><code>package Person;
2241 use Moose;
2242
2243 before work =&gt; sub {
2244     my $self = shift;
2245     die 'I have no job!'
2246         unless $self-&gt;has_title;
2247 };</code></pre>
2248 </div>
2249
2250 <div class="slide">
2251   <h1>Uses for <code>before</code></h1>
2252
2253   <ul>
2254     <li>Logging/Debugging</li>
2255   </ul>
2256
2257   <pre><code>package Person;
2258 use Moose;
2259
2260 before work =&gt; sub {
2261     my $self = shift;
2262     return unless $DEBUG;
2263
2264     warn "Called work on ", $self->full_name,
2265          "with the arguments: [@_]\n";
2266 };</code></pre>
2267 </div>
2268
2269 <div class="slide">
2270   <h1>Uses for <code>after</code></h1>
2271
2272   <ul>
2273     <li>Also works for logging/debugging</li>
2274     <li>Post-X side-effects (recording audit info)</li>
2275   </ul>
2276
2277   <pre><code>package Person;
2278 use Moose;
2279
2280 after work =&gt; sub {
2281     my $self = shift;
2282     $self-&gt;work_count(
2283         $self-&gt;work_count + 1 );
2284 };</code></pre>
2285 </div>
2286
2287 <div class="slide">
2288   <h1>Other Uses</h1>
2289
2290   <ul>
2291     <li>Modifiers are useful for adding behavior to generated methods</li>
2292   </ul>
2293 </div>
2294
2295 <div class="slide">
2296   <h1>Other Uses Example</h1>
2297
2298   <pre><code>has password =&gt; (
2299      is      =&gt; 'rw',
2300      clearer =&gt; 'clear_password',
2301 );
2302
2303 has hashed_password =&gt; (
2304      is      =&gt; 'ro',
2305      builder =&gt; '_build_hashed_password',
2306      clearer =&gt; '_clear_hashed_password',
2307 );
2308
2309 after clear_password =&gt; sub {
2310     my $self = shift;
2311     $self-&gt;_clear_hashed_password;
2312 };</code></pre>
2313 </div>
2314
2315 <div class="slide">
2316   <h1><code>before</code> and <code>after</code> Limitations</h1>
2317
2318   <ul>
2319     <li>Cannot alter method parameters</li>
2320     <li>Cannot alter return value</li>
2321     <li>But <strong>can</strong> throw an exception</li>
2322   </ul>
2323 </div>
2324
2325 <div class="slide">
2326   <h1>The <code>around</code> Modifier</h1>
2327
2328   <ul>
2329     <li>The big gun</li>
2330     <li>Can alter parameters <strong>and/or</strong> return values</li>
2331     <li>Can skip calling the wrapped method entirely</li>
2332   </ul>
2333 </div>
2334
2335 <div class="slide">
2336   <h1>The power of <code>around</code></h1>
2337
2338   <pre><code>around insert =&gt; sub {
2339     my $orig = shift;
2340     my $self = shift;
2341
2342     $self-&gt;_validate_insert(@_);
2343
2344     my $new_user =
2345         $self-&gt;$orig(
2346             $self-&gt;_munge_insert(@_) );
2347
2348     $new_user->_assign_uri;
2349
2350     return $new_user;
2351 };</code></pre>
2352 </div>
2353
2354 <div class="slide">
2355   <h1>Modifier Order</h1>
2356
2357   <ul>
2358     <li>Before runs order from last to first</li>
2359     <li>After runs in order from first to last</li>
2360     <li>Around runs in order from last to first</li>
2361   </ul>
2362 </div>
2363
2364 <div class="slide">
2365   <h1>Modifier Order Illustrated</h1>
2366
2367 <pre>
2368 <span class="current incremental">before 2
2369  before 1</span>
2370   <span class="incremental">around 2
2371    around 1</span>
2372     <span class="incremental">wrapped method</span>
2373    <span class="incremental">around 1
2374   around 2</span>
2375  <span class="incremental">after 1
2376 after 2</span>
2377 </pre>
2378 </div>
2379
2380 <div class="slide">
2381   <h1>Modifiers in Roles</h1>
2382
2383   <ul>
2384     <li>Roles can use these modifiers</li>
2385     <li>Very powerful!</li>
2386   </ul>
2387 </div>
2388
2389 <div class="slide">
2390   <h1>Modifiers in Roles</h1>
2391
2392   <pre><code>package IsUnreliable;
2393 use Moose::Role;
2394
2395 <span class="highlight">requires 'run';
2396
2397 around run</span> =&gt; sub {
2398     my $orig = shift;
2399     my $self = shift;
2400
2401     return if rand(1) &lt; 0.5;
2402
2403     return $self-&gt;$orig(@_);
2404 };</code></pre>
2405 </div>
2406
2407 <div class="slide">
2408   <h1>Augment and Inner</h1>
2409
2410   <ul>
2411     <li>Inverted <code>super</code></li>
2412     <li>From least- to most-specific</li>
2413     <li>Grandparent to parent to child</li>
2414     <li>Not allowed in roles</li>
2415   </ul>
2416 </div>
2417
2418 <div class="slide">
2419   <h1>Augment and Inner</h1>
2420
2421   <pre><code>package Document;
2422
2423 sub xml { '&lt;doc&gt;' . <span class="highlight">inner()</span> . '&lt;/doc&gt;' }
2424
2425 package Report;
2426 extends 'Document';
2427
2428 <span class="highlight">augment xml</span> =&gt;
2429     sub { title() . <span class="highlight">inner()</span> . summary() };
2430
2431 package TPSReport;
2432 extends 'Report';
2433
2434 <span class="highlight">augment xml</span> =&gt;
2435     sub { tps_xml() . <span class="highlight">inner()</span> };</code></pre>
2436 </div>
2437
2438 <div class="slide">
2439   <h1>Augment and Inner</h1>
2440
2441   <ul>
2442     <li>When we call <code>$tps-&gt;xml</code> ...
2443       <ul>
2444         <li><code>Document-&gt;xml</code></li>
2445         <li><code>Report-&gt;xml</code></li>
2446         <li><code>TPSReport-&gt;xml</code></li>
2447       </ul>
2448     </li>
2449   </ul>
2450 </div>
2451
2452 <div class="slide">
2453   <h1>Augment and Inner Usage</h1>
2454
2455   <ul>
2456     <li>Call <code>inner()</code> to "fill in the blank"</li>
2457     <li>Requires designing for subclassing</li>
2458     <li>Call <code>inner()</code> in the terminal class, just in case</li>
2459   </ul>
2460 </div>
2461
2462 <div class="slide">
2463   <h1>Method Modifiers Summary</h1>
2464
2465   <ul>
2466     <li>Use <code>before</code> and <code>after</code> for ...
2467       <ul>
2468         <li>logging</li>
2469         <li>pre- or post-validation</li>
2470         <li>to add behavior to generated methods</li>
2471       </ul>
2472     </li>
2473     <li>These two modifiers cannot change parameters or return values</li>
2474   </ul>
2475 </div>
2476
2477 <div class="slide">
2478   <h1>Method Modifiers Summary</h1>
2479
2480   <ul>
2481     <li>Use <code>around</code> to ...
2482       <ul>
2483         <li>alter parameters passed to the original method</li>
2484         <li>alter the return value of the original method</li>
2485         <li>not call the original method at all (or call a <em>different</em> method)</li>
2486       </ul>
2487     </li>
2488   </ul>
2489 </div>
2490
2491 <div class="slide">
2492   <h1>Method Modifiers Summary</h1>
2493
2494   <ul>
2495     <li>When using modifiers in a role, require the modified method</li>
2496     <li>Use <code>augment</code> and <code>inner</code> to invert the normal subclassing flow ...
2497       <ul>
2498         <li>Least- to most-specific (parents to children)</li>
2499         <li>Build in "insertability" (stick more stuff in the "middle")</li>
2500       </ul>
2501     </li>
2502     <li>Always call <code>inner</code> in the most specific subclass to allow for future extension</li>
2503   </ul>
2504 </div>
2505
2506 <div class="slide">
2507   <h1>Questions?</h1>
2508 </div>
2509
2510 <div class="slide">
2511   <h1>Exercises</h1>
2512
2513   <pre># cd exercises
2514 # perl bin/prove -lv t/04-method-modifiers.t
2515
2516 Iterate til this passes all its tests</pre>
2517 </div>
2518
2519 <div class="slide fake-slide0">
2520   <h1>Part 5: Types</h1>
2521 </div>
2522
2523 <div class="slide">
2524   <h1>A Type System for Perl</h1>
2525
2526   <ul>
2527     <li>Sort of ...</li>
2528     <li><em>Variables</em> are not typed</li>
2529     <li>Attributes can have types</li>
2530     <li>MooseX modules let you define method signatures</li>
2531   </ul>
2532 </div>
2533
2534 <div class="slide">
2535   <h1>Components of a Moose Type</h1>
2536
2537   <ul>
2538     <li>A type is a name and a constraint</li>
2539     <li>Types have a hierarchy</li>
2540     <li>Constraints are cumulative from parents</li>
2541     <li>Types can have associated coercions</li>
2542   </ul>
2543 </div>
2544
2545 <div class="slide">
2546   <h1>Built-in Type Hierarchy</h1>
2547
2548   <pre>
2549 Any
2550 Item
2551     Bool
2552     Maybe[`a]
2553     Undef
2554     Defined
2555         Value
2556            Num
2557              Int
2558            Str
2559              ClassName
2560              RoleName
2561 </pre>
2562 </div>
2563
2564 <div class="slide">
2565   <h1>Built-in Type Hierarchy</h1>
2566
2567 <pre>
2568 (Item)
2569     (Defined)
2570         Ref
2571             ScalarRef
2572             ArrayRef[`a]
2573             HashRef[`a]
2574             CodeRef
2575             RegexpRef
2576             GlobRef
2577               FileHandle
2578             Object
2579 </pre>
2580 </div>
2581
2582 <div class="slide">
2583   <h1>Bool</h1>
2584
2585   <h2>True</h2>
2586   <pre><code>1
2587 924.1
2588 'true'
2589 {}</code></pre>
2590
2591   <h2>False</h2>
2592   <pre><code>0
2593 0.0
2594 '0'
2595 undef</code></pre>
2596
2597   <ul>
2598     <li>Like Perl's <code>if ($foo)</code></li>
2599   </ul>
2600 </div>
2601
2602 <div class="slide">
2603   <h1>Value (and subtypes)</h1>
2604
2605   <ul>
2606     <li><code>Value</code> is true when <code>! ref $thing</code></li>
2607     <li><code>Value</code> and <code>Str</code> are effectively the same, but <code>Str</code> is more expressive</li>
2608     <li>An overloaded object which numifies does not pass the <code>Num</code> constraint!</li>
2609     <li>Perl 5's overloading is hopelessly broken</li>
2610   </ul>
2611 </div>
2612
2613 <div class="slide">
2614   <h1>ClassName and RoleName</h1>
2615
2616   <ul>
2617     <li>A string with a package name</li>
2618     <li>The package <strong>must already be loaded</strong></li>
2619   </ul>
2620 </div>
2621
2622 <div class="slide">
2623   <h1>Parameterizable Types</h1>
2624
2625   <ul>
2626     <li>What does <code>ArrayRef[`a]</code> mean?</li>
2627     <li><code>s/`a/Int/</code> (or <code>Str</code> or ...)</li>
2628     <li>When you use it you can write ...
2629       <ul>
2630         <li><code>ArrayRef</code> (== <code>ArrayRef[Item]</code>)</li>
2631         <li><code>ArrayRef[Str]</code></li>
2632         <li><code>ArrayRef[MyTypeName]</code></li>
2633         <li><code>ArrayRef[HashRef[Maybe[Int]]]</code></li>
2634       </ul>
2635     </li>
2636   </ul>
2637 </div>
2638
2639 <div class="slide">
2640   <h1>Maybe[`a]</h1>
2641
2642   <ul>
2643     <li>Maybe means either the named type or <code>undef</code></li>
2644     <li><code>Maybe[Int]</code> accepts integers or <code>undef</code></li>
2645   </ul>
2646 </div>
2647
2648 <div class="slide">
2649   <h1>Type Union</h1>
2650
2651   <ul>
2652     <li>This or that (or that or ...)</li>
2653     <li><code>Int | ArrayRef[Int]</code></li>
2654     <li>But use a coercion instead when possible</li>
2655     <li>Or use a <code>role_type</code>,  <code>duck_type</code>, or anything not a union</li>
2656     <li>A union is often a code smell</li>
2657   </ul>
2658 </div>
2659
2660 <div class="slide">
2661   <h1>Making Your Own Types</h1>
2662
2663   <pre><code>use Moose::Util::TypeConstraints;
2664
2665 <span class="incremental current">subtype 'PositiveInt',</span>
2666     <span class="incremental">as      'Int',</span>
2667     <span class="incremental">where   { $_ &gt; 0 },</span>
2668     <span class="incremental">message { "The value you provided ($_)"
2669               . " was not a positive number." };</span>
2670
2671 has size =&gt; (
2672     is  =&gt; 'ro',
2673     <span class="incremental">isa =&gt; 'PositiveInt',</span>
2674 );</code></pre>
2675 </div>
2676
2677 <div class="slide">
2678   <h1>Automatic Types</h1>
2679
2680   <ul>
2681     <li>Moose creates a type for every Moose class and role</li>
2682     <li>Unknown names are assumed to be classes</li>
2683   </ul>
2684 </div>
2685
2686 <div class="slide">
2687   <h1>Automatic Types</h1>
2688
2689   <pre><code>package Employee;
2690 use Moose;
2691
2692 has manager =&gt; (
2693     is  =&gt; 'rw',
2694     <span class="highlight">isa =&gt; 'Employee',</span>
2695 );
2696
2697 has start_date =&gt; (
2698     is  =&gt; 'ro',
2699     <span class="highlight">isa =&gt; 'DateTime',</span>
2700 );</code></pre>
2701 </div>
2702
2703 <div class="slide">
2704   <h1>Subtype Shortcuts - <code>class_type</code></h1>
2705
2706   <pre><code>use Moose::Util::TypeConstraints;
2707 class_type 'DateTime';
2708
2709 subtype 'DateTime',
2710     as      'Object',
2711     where   { $_-&gt;isa('DateTime') },
2712     message { ... };</code></pre>
2713 </div>
2714
2715 <div class="slide">
2716   <h1>Subtype Shortcuts - <code>role_type</code></h1>
2717
2718   <pre><code>use Moose::Util::TypeConstraints;
2719 role_type 'Printable';
2720
2721 subtype 'Printable',
2722     as      'Object',
2723     where
2724         { Moose::Util::does_role(
2725               $_, 'Printable' ) },
2726     message { ... };</code></pre>
2727 </div>
2728
2729 <div class="slide">
2730   <h1>Subtype Shortcuts - <code>duck_type</code></h1>
2731
2732   <pre><code>use Moose::Util::TypeConstraints;
2733 duck_type Car =&gt; qw( run break_down );
2734
2735 subtype 'Car',
2736     as      'Object',
2737     where   { all { $_-&gt;can($_) }
2738               qw( run break_down ) },
2739     message { ... };</code></pre>
2740 </div>
2741
2742 <div class="slide">
2743   <h1>Subtype Shortcuts - <code>enum</code></h1>
2744
2745   <pre><code>use Moose::Util::TypeConstraints;
2746 enum Color =&gt; qw( red blue green ) );
2747
2748 my %ok = map { $_ =&gt; 1 } qw( red blue green );
2749 subtype 'Color'
2750     as      'Str',
2751     where   { $ok{$_} },
2752     message { ... };</code></pre>
2753 </div>
2754
2755 <div class="slide">
2756   <h1>Anonymous Subtypes</h1>
2757
2758   <pre><code>package Person;
2759
2760 <span class="highlight">my $posint =
2761     subtype as 'Int', where { $_ &gt; 0 };</span>
2762
2763 has size =&gt; (
2764     is  =&gt; 'ro',
2765     <span class="highlight">isa =&gt; $posint,</span>
2766 );</code></pre>
2767
2768   <ul>
2769     <li>Shortcuts have anonymous forms as well</li>
2770   </ul>
2771 </div>
2772
2773 <div class="slide">
2774   <h1>Coercions</h1>
2775
2776   <pre><code>use Moose::Util::TypeConstraints;
2777
2778 subtype 'UCStr',
2779     as    'Str',
2780     where { ! /[a-z]/ };
2781
2782 <span class="incremental current">coerce 'UCStr',</span>
2783     <span class="incremental">from 'Str',</span>
2784     <span class="incremental">via  { uc };</span>
2785
2786 has shouty_name =&gt; (
2787     is     =&gt; 'ro',
2788     isa    =&gt; 'UCStr',
2789     <span class="incremental">coerce =&gt; 1,</span>
2790 );</code></pre>
2791 </div>
2792
2793 <div class="slide">
2794   <h1>Coercion Examples</h1>
2795
2796   <pre><code>subtype 'My::DateTime',
2797     as class_type 'DateTime';
2798
2799 coerce 'My::DateTime',
2800     from 'HashRef',
2801     via  { DateTime-&gt;new( %{$_} ) };
2802
2803 coerce 'My::DateTime',
2804     from 'Int',
2805     via  { DateTime-&gt;from_epoch(
2806                epoch =&gt; $_ ) };</code></pre>
2807
2808   <ul>
2809     <li>Use coercion to inflate a value</li>
2810   </ul>
2811 </div>
2812
2813 <div class="slide">
2814   <h1>Coercion Examples</h1>
2815
2816   <pre><code>coerce 'ArrayRef[Int]',
2817     from 'Int',
2818     via  { [ $_ ] };</code></pre>
2819
2820   <ul>
2821     <li>Coerce instead of a union like <code style="white-space: nowrap">Int | ArrayRef[Int]</code></li>
2822   </ul>
2823 </div>
2824
2825 <div class="slide">
2826   <h1>Using Types with Attributes</h1>
2827
2828   <pre><code>package Person;
2829
2830 use Moose::Util::TypeConstraints;
2831
2832 has height =&gt; (
2833     is  =&gt; 'rw',
2834     <span class="highlight">isa =&gt; 'Num',</span>
2835 );
2836
2837 has favorite_numbers =&gt; (
2838     is     =&gt; 'rw',
2839     <span class="highlight">isa    =&gt; 'ArrayRef[Int]',
2840     coerce =&gt; 1,</span>
2841 );</code></pre>
2842 </div>
2843
2844 <div class="slide">
2845   <h1>More Droppings</h1>
2846
2847   <ul>
2848     <li><code>Moose::Util::TypeConstraint</code> also needs cleanup</li>
2849   </ul>
2850
2851   <pre><code>package Person;
2852
2853 use Moose;
2854 use Moose::Util::TypeConstraints;
2855
2856 subtype ...;
2857
2858 no Moose;
2859 <span class="highlight">no Moose::Util::TypeConstraints;</span></code></pre>
2860 </div>
2861
2862 <div class="slide">
2863   <h1>Typed Methods (Low-tech)</h1>
2864
2865   <pre class="medium"><code>package Person;
2866 <span class="highlight">use MooseX::Params::Validate qw( validated_list );</span>
2867
2868 sub work {
2869     my $self = shift;
2870     <span class="highlight">my ( $tasks, $can_rest ) =
2871         validated_list(
2872             \@_,
2873             tasks    =&gt;
2874                 { isa    =&gt; 'ArrayRef[Task]',
2875                   coerce =&gt;1 },
2876             can_rest =&gt;
2877                 { isa     =&gt; 'Bool',
2878                   default =&gt; 0 },
2879         );</span>
2880
2881     ...
2882 }</code></pre>
2883 </div>
2884
2885 <div class="slide">
2886   <h1>Typed Methods (High-tech)</h1>
2887
2888   <pre class="medium"><code>package Person;
2889
2890 <span class="highlight">use MooseX::Method::Signatures;</span>
2891
2892 <span class="highlight">method work ( ArrayRef[Task] :$tasks,
2893                         Bool :$can_rest = 0 )</span> {
2894     my $self = shift;
2895
2896     ...
2897 }</code></pre>
2898 </div>
2899
2900 <div class="slide">
2901   <h1>Digression: The Type Registry</h1>
2902
2903   <ul>
2904     <li>Types are actually <code>Moose::Meta::TypeConstraint</code> <em>objects</em></li>
2905     <li>Stored in an interpreter-global registry mapping names to objects</li>
2906   </ul>
2907 </div>
2908
2909 <div class="slide">
2910   <h1>Danger!</h1>
2911
2912   <ul>
2913     <li>Coercions are attached to type objects</li>
2914     <li>Therefore also global</li>
2915     <li>Name conflicts between modules!</li>
2916     <li>Coercion conflicts between modules!</li>
2917   </ul>
2918 </div>
2919
2920 <div class="slide">
2921   <h1>Namespace Fix</h1>
2922
2923   <ul>
2924     <li>Use some sort of pseudo-namespacing scheme</li>
2925     <li>Never coerce directly to a class name, or <em>to</em> built-in types</li>
2926   </ul>
2927 </div>
2928
2929 <div class="slide">
2930   <h1>Namespace Fix</h1>
2931
2932   <pre><code>use Moose::Util::TypeConstraints;
2933
2934 subtype <span class="highlight">'MyApp::Type::DateTime',</span>
2935     as 'DateTime';
2936
2937 <span class="highlight">coerce 'MyApp::Type::DateTime',</span>
2938     from 'HashRef',
2939     via  { DateTime-&gt;new( %{$_} ) }
2940
2941 has creation_date =&gt; (
2942     is     =&gt; 'ro',
2943     <span class="highlight">isa    =&gt; 'MyApp::Type::DateTime',</span>
2944     coerce =&gt; 1,
2945 );</code></pre>
2946 </div>
2947
2948 <div class="slide">
2949   <h1>Namespace Fix</h1>
2950
2951   <pre><code>subtype 'MyApp::Type::ArrayOfInt',
2952     as 'ArrayRef[Int]';
2953
2954 coerce 'MyApp::Type::ArrayOfInt',
2955     from 'Int',
2956     via  { [ $_ ] };</code></pre>
2957 </div>
2958
2959 <div class="slide">
2960   <h1>Namespace Fix Pros and Cons</h1>
2961
2962   <ul>
2963     <li><span class="right">Relatively simple</span></li>
2964     <li><span class="right">Already built into Moose</span></li>
2965     <li><span class="wrong">Conflates type and module namespaces</span></li>
2966     <li><span class="wrong">Type names are strings, so typos are easy to make and may be hard to find</span></li>
2967   </ul>
2968 </div>
2969
2970 <div class="slide">
2971   <h1>MooseX::Types</h1>
2972
2973   <pre><code>package MyApp::Types;
2974
2975 use MooseX::Types
2976     <span class="highlight">-declare =&gt; [ qw( ArrayOfInt ) ]</span>;
2977 use MooseX::Types::Moose
2978     qw( ArrayRef Int );
2979
2980 subtype <span class="highlight">ArrayOfInt</span>,
2981     as ArrayRef[Int];
2982
2983 coerce <span class="highlight">ArrayOfInt</span>
2984     from Int,
2985     via  { [ $_ ] };</code></pre>
2986 </div>
2987
2988 <div class="slide">
2989   <h1>MooseX::Types</h1>
2990
2991   <pre><code>package MyApp::Account;
2992
2993 use MyApp::Types qw( ArrayOfInt );
2994
2995 has transaction_history => (
2996     is  => 'rw',
2997     isa => ArrayOfInt,
2998 );</code></pre>
2999 </div>
3000
3001 <div class="slide">
3002   <h1>MooseX::Types</h1>
3003
3004   <ul>
3005     <li>Type names are exported functions, catches typos early</li>
3006     <li>Types must be pre-declared</li>
3007     <li>Types are stored with namespaces internally, but externally are short</li>
3008     <li>Import existing Moose types as functions from <code>MooseX::Types::Moose</code></li>
3009     <li>Still need string names for things like <code>ArrayRef['Email::Address']</code></li>
3010   </ul>
3011 </div>
3012
3013 <div class="slide">
3014   <h1>MooseX::Types Pros and Cons</h1>
3015
3016   <ul>
3017     <li><span class="right">Catches typos at compile time</span></li>
3018     <li><span class="right">Automatic namespacing</span></li>
3019     <li><span class="wrong">One more thing to install and learn</span></li>
3020     <li><span class="wrong">Every name gets types twice (declared and then defined)</span></li>
3021     <li><span class="wrong">Still stuck with strings when referring to class or role names</span></li>
3022     <li><span class="wrong">Coercion gotcha from earlier still applies to types exported from <code>MooseX::Types::Moose</code></span></li>
3023   </ul>
3024 </div>
3025
3026 <div class="slide">
3027   <h1>Recommendation</h1>
3028
3029   <ul>
3030     <li>Use <code>MooseX::Types</code></li>
3031     <li>Compile time error catching and automatic namespacing are huge wins</li>
3032     <li>Docs from <code>Moose::Util::TypeConstraints</code> are 98% compatible with <code>MooseX::Types</code> anyway</li>
3033     <li>A function exported by a type library works wherever a type name would</li>
3034   </ul>
3035 </div>
3036
3037 <div class="slide">
3038   <h1>Questions?</h1>
3039 </div>
3040
3041 <div class="slide">
3042   <h1>Exercises</h1>
3043
3044   <pre># cd exercises
3045 # perl bin/prove -lv t/05-types.t
3046
3047 Iterate til this passes all its tests</pre>
3048 </div>
3049
3050 <div class="slide fake-slide0">
3051   <h1>Part 6: Advanced Attributes</h1>
3052 </div>
3053
3054 <div class="slide">
3055   <h1>Weak References</h1>
3056
3057   <ul>
3058     <li>A weak reference lets you avoid circular references</li>
3059     <li>Weak references do not increase the reference count</li>
3060   </ul>
3061 </div>
3062
3063 <div class="slide">
3064   <h1>Circular Reference Illustrated</h1>
3065
3066   <pre><code>my $foo = {};
3067 my $bar = { foo =&gt; $foo };
3068 $foo-&gt;{bar} = $bar;</code></pre>
3069
3070   <ul>
3071     <li>Neither <code>$foo</code> nor <code>$bar</code> go out of scope<br />
3072         (until the program exits)</li>
3073   </ul>
3074 </div>
3075
3076 <div class="slide">
3077   <h1>Weakening Circular References</h1>
3078
3079   <pre><code>use Scalar::Util qw( weaken );
3080
3081 my $foo = {};
3082 my $bar = { foo =&gt; $foo };
3083 $foo-&gt;{bar} = $bar;
3084 weaken $foo-&gt;{bar}</code></pre>
3085
3086   <ul>
3087     <li>When <code>$bar</code> goes out of scope, <code>$foo-&gt;{bar}</code> becomes <code>undef</code></li>
3088   </ul>
3089 </div>
3090
3091 <div class="slide">
3092   <h1>Circular References in Attributes</h1>
3093
3094   <pre><code>package Person;
3095 use Moose;
3096
3097 has name   =&gt; ( is =&gt; 'ro' );
3098 has friend =&gt; ( is =&gt; 'rw' );
3099
3100 my $alice = Person-&gt;new( name =&gt; 'Alice' );
3101 my $bob   = Person-&gt;new( name =&gt; 'Bob' );
3102 $bob-&gt;friend($alice);
3103 $alice-&gt;friend($bob);</code></pre>
3104 </div>
3105
3106 <div class="slide">
3107   <h1>The Fix</h1>
3108
3109   <pre><code>package Person;
3110 use Moose;
3111
3112 has name   =&gt; ( is =&gt; 'ro' );
3113 has friend =&gt; ( is =&gt; 'rw', <span class="highlight">weak_ref =&gt; 1</span> );
3114
3115 my $alice = Person-&gt;new( name =&gt; 'Alice' );
3116 my $bob   = Person-&gt;new( name =&gt; 'Bob' );
3117 $bob-&gt;friend($alice);
3118 $alice-&gt;friend($bob);</code></pre>
3119 </div>
3120
3121 <div class="slide">
3122   <h1>Under the Hood</h1>
3123
3124   <ul>
3125     <li>A <code>weak_ref</code> attribute calls <code>weaken</code> ...
3126       <ul>
3127         <li>during object construction</li>
3128         <li>when the attribute is set via a writer</li>
3129       </ul>
3130     </li>
3131   </ul>
3132 </div>
3133
3134 <div class="slide">
3135   <h1>Triggers</h1>
3136
3137   <ul>
3138     <li>A code reference run after an attribute is <em>set</em></li>
3139     <li>Like an <code>after</code> modifier, but makes intentions clearer</li>
3140   </ul>
3141
3142   <h2 class="wrong">Gross</h2>
3143
3144   <pre><code>after salary_level =&gt; {
3145     my $self = shift;
3146     return unless @_;
3147     $self-&gt;clear_salary;
3148 };</code></pre>
3149 </div>
3150
3151 <div class="slide">
3152   <h1>Use a Trigger Instead</h1>
3153
3154   <h2 class="right">Cleaner</h2>
3155
3156   <pre><code>has salary_level =&gt; (
3157     is      =&gt; 'rw',
3158     trigger =&gt; sub { $_[0]-&gt;clear_salary },
3159 );</code></pre>
3160 </div>
3161
3162 <div class="slide">
3163   <h1>Delegation</h1>
3164
3165   <ul>
3166     <li>Attributes can be objects</li>
3167     <li>Delegation transparently calls methods on those objects</li>
3168   </ul>
3169 </div>
3170
3171 <div class="slide">
3172   <h1>Delegation Examples</h1>
3173
3174   <pre><code>package Person;
3175
3176 has lungs =&gt; (
3177     is      =&gt; 'ro',
3178     isa     => 'Lungs',
3179     <span class="highlight">handles =&gt; [ 'inhale', 'exhale' ],</span>
3180 );</code></pre>
3181
3182   <ul>
3183     <li>Creates <code>$person-&gt;inhale</code> and <code>-&gt;exhale</code> methods</li>
3184     <li>Internally calls <code>$person-&gt;lungs-&gt;inhale</code></li>
3185   </ul>
3186 </div>
3187
3188 <div class="slide">
3189   <h1>Why Delegation?</h1>
3190
3191   <ul>
3192     <li>Reduce the number of classes exposed</li>
3193     <li>Re-arrange class internals -<br />
3194         turn a method into an attribute with delegation</li>
3195     <li>Provide convenenience methods</li>
3196   </ul>
3197 </div>
3198
3199 <div class="slide">
3200   <h1>Moose's <code>handles</code> Parameter</h1>
3201
3202   <ul>
3203     <li>Accepts many arguments ...
3204       <ul>
3205         <li>Array reference - list of methods to delegate as-is</li>
3206         <li>Hash reference - map of method names</li>
3207         <li>Regex - delegates all matching methods</li>
3208         <li>Role name - delegates all methods in the role</li>
3209         <li>Sub reference - does something complicated ;)</li>
3210       </ul>
3211     </li>
3212   </ul>
3213 </div>
3214
3215 <div class="slide">
3216   <h1>Array Reference</h1>
3217
3218   <ul>
3219     <li>Takes each method name and creates a simple delegation from the delegating class to the delegatee attribute</li>
3220   </ul>
3221 </div>
3222
3223 <div class="slide">
3224   <h1>Hash Reference</h1>
3225
3226   <ul>
3227     <li>Mapping of names in the delegating class to the delegatee class</li>
3228   </ul>
3229
3230   <pre><code>package Person;
3231 use Moose;
3232
3233 has account =&gt; (
3234     is      =&gt; 'ro',
3235     isa     =&gt; 'BankAccount',
3236     <span class="highlight">handles =&gt; {
3237         receive_money =&gt; 'deposit',
3238         give_money    =&gt; 'withdraw',
3239     },</span>
3240 );</code></pre>
3241 </div>
3242
3243 <div class="slide">
3244   <h1>Hash Reference Detailed</h1>
3245
3246   <pre><code>    handles =&gt; {
3247         receive_money =&gt; 'deposit',
3248         give_money    =&gt; 'withdraw',
3249     },</code></pre>
3250
3251   <ul>
3252     <li><code>$person-&gt;receive_money</code> = <code>$person-&gt;account-&gt;deposit</code></li>
3253     <li><code>$person-&gt;give_money</code> = <code>$person-&gt;account-&gt;withdraw</code></li>
3254   </ul>
3255 </div>
3256
3257 <div class="slide">
3258   <h1>Regex</h1>
3259
3260   <pre><code>package Person;
3261 use Moose;
3262
3263 has name =&gt; (
3264     is      =&gt; 'ro',
3265     isa     =&gt; 'Name',
3266     handles =&gt; qr/.*/,
3267 );</code></pre>
3268
3269   <ul>
3270     <li>Creates a delegation for every method in the Name class</li>
3271     <li>Excludes <code>meta</code> and methods inherited from <code>Moose::Object</code></li>
3272   </ul>
3273 </div>
3274
3275 <div class="slide">
3276   <h1>Role Name</h1>
3277
3278   <pre><code>package Auditor;
3279 use Moose::Role;
3280
3281 sub record_change  { ... }
3282 sub change_history { ... }
3283
3284 package Account;
3285 use Moose;
3286
3287 has history =&gt; (
3288     is      =&gt; 'ro',
3289     does    =&gt; 'Auditor',
3290     <span class="highlight">handles =&gt; 'Auditor',</span>
3291 );</code></pre>
3292 </div>
3293
3294 <div class="slide">
3295   <h1>Role Name Detailed</h1>
3296
3297   <ul>
3298     <li>Account gets delegate methods for each method in the <code>Auditor</code> role
3299       <ul>
3300         <li>record_history</li>
3301         <li>change_history</li>
3302       </ul>
3303     </li>
3304   </ul>
3305 </div>
3306
3307 <div class="slide">
3308   <h1>Native Delegation</h1>
3309
3310   <ul>
3311     <li>Delegate to <em>unblessed</em> Perl types</li>
3312     <li>Scalar, array or hash ref, etc</li>
3313   </ul>
3314 </div>
3315
3316 <div class="slide">
3317   <h1>Native Delegation - Array</h1>
3318
3319   <pre><code>package Person;
3320 use Moose;
3321
3322 has _favorite_numbers =&gt; (
3323     traits   =&gt; [ 'Array' ],
3324     is       =&gt; 'ro',
3325     isa      =&gt; 'ArrayRef[Int]',
3326     default  =&gt; sub { [] },
3327     init_arg =&gt; undef,
3328     <span class="highlight">handles  =&gt;
3329       { favorite_numbers    =&gt; 'elements',
3330         add_favorite_number =&gt; 'push',
3331       },</span>
3332 );</code></pre>
3333
3334   <ul>
3335     <li>Automatically defaults to <code>[]</code></li>
3336   </ul>
3337 </div>
3338
3339 <div class="slide">
3340   <h1>Native Delegation - Counter</h1>
3341
3342   <pre><code>package Stack;
3343 use Moose;
3344
3345 has depth =&gt; (
3346     traits   =&gt; [ 'Counter' ],
3347     is       =&gt; 'ro',
3348     isa      =&gt; 'Int',
3349     default  =&gt; 0,
3350     init_arg =&gt; undef,
3351     <span class="highlight">handles  =&gt;
3352       { _inc_depth =&gt; 'inc',
3353         _dec_depth =&gt; 'dec',
3354       },</span>
3355 );</code></pre>
3356 </div>
3357
3358
3359 <div class="slide">
3360   <h1>Traits and Metaclasses</h1>
3361
3362   <ul>
3363     <li>The ultimate in customization</li>
3364     <li>Per attribute metaclasses</li>
3365     <li>Per attribute roles applied to the attribute metaclass</li>
3366     <li>Change the meta-level behavior</li>
3367   </ul>
3368 </div>
3369
3370 <div class="slide">
3371   <h1>Traits and Metaclasses</h1>
3372
3373   <ul>
3374     <li>The default metaclass is <code>Moose::Meta::Attribute</code></li>
3375     <li>Controls accessor generation, defaults, delegation, etc.</li>
3376     <li>Adding a role to this metaclass (or replacing it) allows for infinite customization</li>
3377   </ul>
3378 </div>
3379
3380 <div class="slide">
3381   <h1>Traits and Metaclasses</h1>
3382
3383   <ul>
3384     <li>Can add/alter/remove attribute parameter (from <code>has</code>)</li>
3385     <li>Can change behavior of created attribute</li>
3386   </ul>
3387 </div>
3388
3389 <div class="slide">
3390   <h1>Simple Trait Example</h1>
3391
3392   <pre><code>package Person;
3393 use Moose;
3394 use MooseX::LabeledAttributes;
3395
3396 has ssn =&gt; (
3397     <span class="highlight">traits =&gt; [ 'Labeled' ],</span>
3398     is     =&gt; 'ro',
3399     isa    =&gt; 'Str',
3400     <span class="highlight">label  =&gt; 'Social Security Number',</span>
3401 );
3402
3403 print <span class="highlight">Person-&gt;meta
3404             -&gt;get_attribute('ssn')-&gt;label;</span></code></pre>
3405 </div>
3406
3407 <div class="slide">
3408   <h1>Simple Metaclass Example</h1>
3409
3410   <pre><code>package Person;
3411 use Moose;
3412 use MooseX::LabeledAttributes;
3413
3414 has ssn =&gt; (
3415     <span class="highlight">metaclass =&gt;
3416         'MooseX::Meta::Attribute::Labeled',</span>
3417     is        =&gt; 'ro',
3418     isa       =&gt; 'Str',
3419     <span class="highlight">label     =&gt; 'Social Security Number',</span>
3420 );
3421
3422 print <span class="highlight">Person-&gt;meta
3423             -&gt;get_attribute('ssn')-&gt;label;</span></code></pre>
3424 </div>
3425
3426 <div class="slide">
3427   <h1>Traits vs Metaclass</h1>
3428
3429   <ul>
3430     <li>Can apply any mix of traits to an attribute</li>
3431     <li>But just one metaclass</li>
3432     <li>Traits (aka roles) can cooperate</li>
3433     <li>Metaclasses require you to pick just one</li>
3434   </ul>
3435 </div>
3436
3437 <div class="slide">
3438   <h1>Advanced Attributes Summary</h1>
3439
3440   <ul>
3441     <li>Use <code>weak_ref</code> to avoid circular references</li>
3442     <li>Use trigger to do an action post-attribute write</li>
3443     <li>Use delegations to hide "internal" objects</li>
3444     <li>Traits and metaclasses let you extend Moose's core attribute features</li>
3445   </ul>
3446 </div>
3447
3448 <div class="slide">
3449   <h1>Questions?</h1>
3450 </div>
3451
3452 <div class="slide">
3453   <h1>Exercises</h1>
3454
3455   <pre># cd exercises
3456 # perl bin/prove -lv t/06-advanced-attributes.t
3457
3458 Iterate til this passes all its tests</pre>
3459 </div>
3460
3461 <div class="slide fake-slide0">
3462   <h1>Part 7: Introspection</h1>
3463 </div>
3464
3465 <div class="slide fake-slide0">
3466   <h1>Part 8: A Tour of MooseX</h1>
3467 </div>
3468
3469 <div class="slide fake-slide0">
3470   <h1>Part 9: Writing Moose Extensions</h1>
3471 </div>
3472
3473 <div class="slide fake-slide0">
3474   <h1>The End</h1>
3475 </div>
3476
3477 <div class="slide">
3478   <h1>More Information</h1>
3479
3480   <ul>
3481     <li><a href="http://moose.perl.org/">http://moose.perl.org/</a></li>
3482     <li><a href="http://search.cpan.org/dist/Moose/lib/Moose/Manual.pod">Moose::Manual</a> and <a href="http://search.cpan.org/dist/Moose/lib/Moose/Cookbook.pod">Moose::Cookbook</a></li>
3483     <li><a href="irc://irc.perl.org/#moose">irc://irc.perl.org/#moose</a></li>
3484     <li>mailing list - <a href="mailto:moose@perl.org">moose@perl.org</a></li>
3485     <li>Slides and exercises are in Moose's git repo:
3486         <br />
3487         <span style="white-space: nowrap">git://jules.scsys.co.uk/gitmo/moose-presentations</span></li>
3488   </ul>
3489 </div>
3490
3491 </div>
3492 </body>
3493 </html>
3494
3495 <!--
3496
3497 Copyright 2009 David Rolsky. All Rights Reserved.
3498
3499 This work is licensed under a Creative Commons Attribution-Share Alike
3500 3.0 United States License See
3501 http://creativecommons.org/licenses/by-sa/3.0/us/ for details.
3502
3503 -->