The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.

NAME

Class::Prototyped::Mixin - Mixin Support for Class::Prototyped

SYNOPSIS

Usage one: whip up a class and toss it in a scalar

 package HelloWorld;

 sub hello { 
  my ($self, $age) = @_;
  return "Hello World! I am $age years old" 
 }


 package HelloWorld::Uppercase;
 use base qw(Class::Prototyped);

 __PACKAGE__->reflect->addSlot(
  [qw(hello superable)] => sub {
    my $self = shift;
    my $ret = $self->reflect->super('hello', @_);
    uc $ret
  }
 );


 package HelloWorld::Bold;
 use base qw(Class::Prototyped);

 __PACKAGE__->reflect->addSlot(
  [qw(hello superable)] => sub {
    my $self = shift;
    my $ret = $self->reflect->super('hello', @_);
    "<b>$ret</b>";
  }
 );

  
 package HelloWorld::Italic;
 use base qw(Class::Prototyped);

 __PACKAGE__->reflect->addSlot(
  [qw(hello superable)] => sub {
    my $self = shift;
    my $ret = $self->reflect->super('hello', @_);
    "<i>$ret</i>";
  }
 );

 # script.pl - now the whipping begins
 use Class::Prototyped::Mixin qw(mixin);
 my $runtime = mixin(
     'HelloWorld' => 'HelloWorld::Uppercase', 'HelloWorld::Italic'
 );

 print $runtime->hello(74);
 <i>HELLO WORLD! I AM 74 YEARS OLD</i>

Usage two: create hierarchy and install in a Class::Prototyped package

 package CompileTime;
 use Class::Prototyped::Mixin qw(mixin);

 my $uclass = mixin(
  'HelloWorld' => 'HelloWorld::Uppercase', 'HelloWorld::Bold'
 );

 __PACKAGE__->reflect->addSlot(
  '*' => $uclass
 );


 # script.pl
 use CompileTime;

 print CompileTime->hello(88);
 <b>HELLO WORLD! I AM 88 YEARS OLD</b>

DESCRIPTION

This module aids prototyped-based object programming in Perl by making it easy to layer functionality on base functionality via a collection of mixin classes. The SYNOPSIS is admittedly easier done via a fold or some other pure functional approach. However, the case for intelligent, "performant" mixins is argued strongly here: http://www.mail-archive.com/sw-design@metaperl.com/msg00060.html

To date, the Mixin contributions to CPAN use class-based OOP, with Class::MixinFactory being perhaps the most complete and best documented. This module is one of a series designed to show the flexibility, simplicity and power of prototyped-based object programming.

The reason I wish to address object-oriented design concerns in prototype-based object-oriented programming is that it is simple, flexible and seems to involve less confusion than I see evolving with Perl class-based oop. For awhile there was interest in roles. Now there is interest in traits. And there has always been a long-standing interest in mixins, decoration, and delegation.

I cringe at the thought of trying to get all of these technologies to meld in a large project. I cringe equally at those who talk and do not do: The last thing that is necessary is for me to SAY that prototyped-based oop can address real-world concerns yet not DEMONSTRATE.

AUTHOR

        Terrence Brannon
        CPAN ID: TBONE
        metaperl.com
        metaperl@gmail.com
        http://www.metaperl.com

SOURCES

Distributed on CPAN.

CVS access is via:

  cvs -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/sw-design login

  cvs -z3 -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/sw-design co -P cpmixin

COPYRIGHT

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

The full text of the license can be found in the LICENSE file included with this module.

SEE ALSO

METHODS

mixin

 Usage     : Class::Prototyped::Mixin::mixin($base, $derived, $derived_two, ..)
 Purpose   : Dynamically build an object with the specified inheritance
 Returns   : a Class::Prototyped object
 Argument  : a list of classes, starting from the root class and moving
             down the hierarchy
 Throws    : Returns undef if at least 2 classes are not passed in for mixing
 Comment   : This is a sample subroutine header.
           : It is polite to include more pod and fewer comments.