Toby Inkster > MooseX-Prototype-0.004 > MooseX::Prototype

Download:
MooseX-Prototype-0.004.tar.gz

Dependencies

Annotate this POD

Website

View/Report Bugs
Module Version: 0.004   Source  

NAME ^

MooseX::Prototype - prototype-based programming for Moose

SYNOPSIS ^

From Wikipedia: "Prototype-based programming is a style of object-oriented programming in which classes are not present, and behaviour reuse (known as inheritance in class-based languages) is performed via a process of cloning existing objects that serve as prototypes."

   use MooseX::Prototype;
   
   my $Person = object {
      name       => undef,
   };
   
   my $Employee = $Person->new->extend({
      job        => undef,
      employer   => undef,
   });
   
   my $CivilServant = $Employee->new(
      employer   => 'Government',
   );
   
   $CivilServant->extend({
      department => undef,
   });
   
   my $bob = $CivilServant->new(
      name       => 'Robert',
      department => 'HMRC',
      job        => 'Tax Inspector',
   );
   
   print $bob->dump;
   
   # $VAR1 = bless( {
   #    name       => 'Robert',
   #    job        => 'Tax Inspector',
   #    department => 'HMRC',
   #    employer   => 'Government'
   # }, 'MooseX::Prototype::__ANON__::0006' );

DESCRIPTION ^

Due to familiarity with class-based languages such as Java, many programmers assume that object-oriented programming is synonymous with class-based programming. However, class-based programming is just one kind of object-oriented programming style, and other varieties exist such as role-oriented, aspect-oriented and prototype-based programming.

A prominent example of a prototype-based programming language is ECMAScript (a.k.a. Javascript/JScript/ActionScript). ECMAScript does provide a thin class-like layer over the top of its prototype-based OO system, which some (even experienced) ECMAScript developers rarely see beyond.

This module implements a thin prototype-like layer on top of Moose's class/role-based toolkit.

Ex-Nihilo Object Creation

In prototype-based languages, objects are created by cloning other objects. But it's often useful to be able to magic up an object out of nowhere. MooseX::Prototype provides a convenience function to do this:

object \%attrs

Creates a new object with the given attributes. The hash is treated as attribute-name, attribute-value pairs, but any names beginning with "&" are installed as methods. For example:

   my $person = object {
      "name"         => "Robert",
      "&changeName"  => sub {
         my ($self, $newname) = @_;
         $self->name($newname);
      },
   };

Objects created this way inherit from Moose::Object and perform the MooseX::Prototype::Trait::Object role.

Creating Objects from a Prototype

A prototype is just an object. When you create a new object from it, the prototype will be cloned and the new object will inherit all its attributes and methods.

$prototype->new(%attrs)

Creates a new object which inherits its methods and attributes from $prototype. The %attrs hash can override attribute values from the prototype, but cannot add new attributes or methods.

This method is provided by the MooseX::Prototype::Trait::Object role, so $prototype must perform that role.

$prototype->create_class

Rather than creating a new object from a prototype, this creates a whole new Moose class which can be used to instantiate objects. If you need to create a whole bunch of objects from a prototype, it is probably more efficient to create a class and use that, rather than just calling new a bunch of times.

The class can be given a name, a la:

   $prototype->create_class("Foo::Bar");

Otherwise an arbitary name will be generated and returned.

This method is provided by the MooseX::Prototype::Trait::Object role, so $prototype must perform that role.

create_class_from_prototype($prototype)

A convenience function allowing you to use arbitary Moose objects (which lack the create_class method) as prototypes.

Also note:

   my $obj = create_class_from_prototype($proto)->new(%attrs);

This function is not exported by default, but can be exported using:

   use MooseX::Prototype -all;

Extending Existing Objects

A key feature of Javascript is that new attributes and methods can be given to an object using simple assignment;

   my_object.some_attribute = 123;
   my_object.some_method = function () { return 456 };

In MooseX::Prototype, there is an explicit syntax for adding new attributes and methods to an object.

$object->extend(\%attrs)

As per ex-nihilo object creation, the attribute hashref can define attribute name-value pairs, or new methods with a leading "&".

HISTORY ^

Version 0.001 of MooseX::Prototype consisted of just a single function, use_as_prototype which was much the same as create_class_from_prototype.

Version 0.002 is an almost complete rewrite.

BUGS ^

Please report any bugs to http://rt.cpan.org/Dist/Display.html?Queue=MooseX-Prototype.

SEE ALSO ^

Object::Prototype, Class::Prototyped, JE::Object.

AUTHOR ^

Toby Inkster <tobyink@cpan.org>.

COPYRIGHT AND LICENCE ^

This software is copyright (c) 2012 by Toby Inkster.

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

DISCLAIMER OF WARRANTIES ^

THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.

syntax highlighting: