Meta-Moose

Portland, Oregon

April 8th, 2009

Plan

• overlap between Moose and other common modules
• remedial Moose
• more advanced features
• type constraints
• roles
• the Meta-Object Protocol (MOP)
• basics
• extending Moose

Plan

• demystify Moose
• show how naming a thing gives you power over it
• code reuse
• code clarity

Attributes

• hand-rolled

sub foo {
  my $self = shift;
  $self->{foo} = shift if @_;
  return $self->{foo};
}

• Class::Accessor

__PACKAGE__->mk_accessors(qw(foo));

• Moose

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

http://search.cpan.org/perldoc?Moose::Manual::Attributes

Method Modifiers

• by hand

package Parent;
sub foo { print "I'm a foo!"; return 17 }

package Child;
sub foo {
  my $self = shift;
  die "argh!" unless $self->is_valid;
  my $rv = $self->SUPER::foo(@_);
  print "A little kid foo!";
  return $rv + 5;
}

• Moose

package Child;
before foo => sub {
  die "argh!" unless shift->is_valid;
};

after foo => sub {
  print "A little kid foo!";
};

around foo => sub {
  my $next = shift;
  return shift->$next(@_) + 5;
};

http://search.cpan.org/perldoc?Moose::Manual::MethodModifiers

More

• basic Moose concepts
• http://search.cpan.org/perldoc?Moose::Manual::Concepts
• comparison with vanilla Perl 5
• http://search.cpan.org/perldoc?Moose::Unsweetened

Type Constraints

• generic validation system

• built-in types: Int, Str, HashRef, etc.

use MooseX::Types::Moose qw(Int Str ArrayRef HashRef);

• use by hand

my $tc = find_type_constraint(HashRef);
if ($tc->check($input)) { ... }

• use in attributes

has foo => (is => 'rw', isa => HashRef);

• use in methods

use MooseX::Params::Validate;
sub foo {
  my ($self, %arg) = validated_hash(
    \@_,
    bar => { isa => Int },
  )
}

• some types are parameterizable

has foo => (is => 'rw', isa => ArrayRef[Int]);

Subtyping

• declare your own types

use MooseX::Types::Moose qw(Int ArrayRef);
use MooseX::Types -declare => [ qw(PosInt PosEvenInt PosIntTriplet) ];

subtype PosInt,
  as Int,
  where { $_ > 0 },
  message { "Int is not greater than 0" };

subtype PosEvenInt,
  as PosInt,
  where { $_ % 2 == 0 },
  message { "Int is not even" };

subtype PosIntTriplet,
  as ArrayRef[PosInt],
  where { @$_ == 3 },
  message { "Must have exactly 3 PosInts" };

Type Constraint Libraries

• export type definitions

package MyApp::Types;
use MooseX::Types -declare => [ 'PosInt' ];
subtype PosInt, ...

package MyApp;
use MyApp::Types qw(PosInt);

has awesome => (isa => PosInt); # don't let awesomeness drop to 0

• avoids namespacing issues

Type Constraints

• Phase 1: validate

Type Constraints

• Phase 1: validate

• Phase 2: ???

Type Constraints

• Phase 1: validate

• Phase 2: ???

• Phase 3: profit!

Type Coercions

• never write this again

sub read_file {
  my ($self, $file) = @_;
  unless (blessed $file) {
    $file = IO::File->new('<', $file);
  }
  # ... do something with $file
}

Type Coercions

• never write this again

sub read_file {
  my ($self, $file) = @_;
  unless (blessed $file) {
    $file = IO::File->new('<', $file);
  }
  # ... do something with $file
}

• instead, declare your own File type

use MooseX::Types -declare => ['File'];

subtype File, as 'IO::File';

• and coerce it from a string (Str)

coerce File,
  from Str,
  via { IO::File->new('<', $_) or die "Can't open $_: $!" };

package MyApp::FileReader;
use Moose; 
use MyApp::Types qw(File);
has input_file => (is => 'rw', isa => File, coerce => 1);

# elsewhere
$f = MyApp::FileReader->new(input_file => $fh);
$f = MyApp::FileReader->new(input_file => '/some/file');

Profit

• reach for type constraints early
• refactor like any other code
• don't be afraid to make "single-use" types if they're distinct
• use MooseX::Types to reuse types

http://search.cpan.org/perldoc?Moose::Manual::Types

http://search.cpan.org/perldoc?MooseX::Types

http://search.cpan.org/perldoc?Moose::Util::TypeConstraints

Roles

• subsumes 'interfaces', 'mixins', 'traits'
• describe behavior, using verbs or active nouns: HasWhereClause, MakesAliasObjects, HTMLParser
• named sets of exported methods, modifiers, and attributes
• reusable pieces of class-related functionality
• like duck typing, but explicitly named
• solves Dog vs. Tree
• allows more composition

Role as interface

package Fey::Role::Named;
use Moose::Role;
requires 'name';

• consumed by tables and columns

Role as label

package Fey::Role::Joinable;
use Moose::Role;
sub is_joinable { 1 }

• consumed by tables and selects

Role as complex definition

• http://search.cpan.org/perldoc?Fey::Role::ColumnLike
• gather up smaller roles

Role as complex behavior

• http://search.cpan.org/perldoc?Fey::Role::SQL::HasWhereClause
• attributes and methods that use them

Roles on objects

• http://search.cpan.org/perldoc?WWW::Mechanize::TreeBuilder

my $mech = WWW::Mechanize->new;
WWW::Mechanize::TreeBuilder->meta->apply($mech);

# adds $mech->look_down, etc.

Roles > Inheritance

• immediate composition, method resolution, conflict reporting
• no lost/hidden methods, unlike multiple inheritance
• no more of this

sub driver_name { croak "A subclass should override this!" }

• scalability++

http://search.cpan.org/perldoc?Moose::Manual::Roles

Meta Object Protocol (MOP)

• defines basic OO components
• class -> metaclass object
• role -> metarole object
• object -> meta-instance object
• method -> metamethod object
• attribute -> meta-attribute object
• and more

MooseX-tension

http://search.cpan.org/perldoc?MooseX::StrictConstructor

• use the meta-attribute objects for introspection
• use Moose::Exporter to hook into use
• use Moose::Util::MetaRole to add behavior to meta-* objects

http://search.cpan.org/perldoc?Moose::Cookbook::Extending::Recipe1

The End

• thanks!