Class building as simple as it gets
# Define a class
package Foo;
use Object::Tiny qw{ bar baz };
1;
# Use the class
my $object = Foo->new( bar => 1 );
print "bar is " . $object->bar . "\n";
There's a whole bunch of class builders out there. In fact, creating a class builder seems to be something of a rite of passage (this is my fifth, at least).
Unfortunately, most of the time I want a class builder I'm in a hurry and sketching out lots of fairly simple data classes with fairly simple structure, mostly just read-only accessors, and that's about it.
Often this is for code that won't end up on \s-1CPAN\s0, so adding a small dependency doesn't matter much. I just want to be able to define these classes \s-1FAST\s0.
By which I mean \s-1LESS\s0 typing than writing them by hand, not more. And I don't need all those weird complex features that bloat out the code and take over the whole way I build modules.
And so, I present yet another member of the Tiny family of modules, Object::Tiny.
The goal here is really just to save me some typing. There's others that could do the job just fine, but I want something that does as little as possible and creates code the same way I'd have written it by hand anyway.
To use Object::Tiny, just call it with a list of accessors to be created.
use Object::Tiny 'foo', 'bar';
For a large list, I lay it out like this...
use Object::Tiny qw{ item_font_face item_font_color item_font_size item_text_content item_display_time seperator_font_face seperator_font_color seperator_font_size seperator_text_content };
This will create a bunch of simple accessors, and set the inheritance to be the child of Object::Tiny.
Object::Tiny is empty other than a basic \*(C`new\*(C' constructor which does the following
sub new { my $class = shift; return bless { @_ }, $class; }
In fact, if doing the following in your class gets annoying...
sub new { my $class = shift; my $self = $class->SUPER::new( @_ );
# Extra checking and such ...
return $self; }
... then feel free to ditch the \s-1SUPER\s0 call and just create the hash yourself! It's not going to make a lick of different and there's nothing magic going on under the covers you might break.
And that's really all there is to it. Let a million simple data classes bloom. Features? We don't need no stinking features.
If the class you are using Object::Tiny for is already a subclass of another Object::Tiny class (or a subclass of anything else) it doesn't really work to make the class use multiple inheritance.
So in this case, Object::Tiny will create the accessors you specify, but \s-1WON\s0'T make it a subclass of Object::Tiny.
As a class builder, Object::Tiny inevitably is compared to Class::Accessor and related modules. They seem so similar, so why would I reimplement it?
The answer is that for experienced developers that don't need or want hand-holding, Object::Tiny is just outright better, faster or cheaper on every single metric than Class::Accessor::Fast, which is the most comparable member of the Class::Accessor::* family.
Object::Tiny is 93% smaller than Class::Accessor::Fast
Class::Accessor::Fast requires about 125k of memory to load.
Object::Tiny requires about 8k of memory to load.
Object::Tiny is 75% more terse to use than Class::Accessor::Fast
Object::Tiny is used with the least possible number of keystrokes (short of making the actual name Object::Tiny smaller).
And it requires no ugly constructor methods.
I mean really, what sort of a method name is 'mk_ro_accessors'. That sort of thing went out of style in the early nineties.
Using Class::Accessor::Fast...
package Foo::Bar; use base 'Class::Accessor::Fast'; Foo::Bar->mk_ro_accessors(qw{ foo bar baz });
Using Object::Tiny...
package Foo::Bar; use Object::Tiny qw{ foo bar baz };
Further, Object::Tiny lets you pass your params in directly, without having to wrap them in an additional \s-1HASH\s0 reference that will just be copied \s-1ANYWAY\s0 inside the constructor.
Using Class::Accessor::Fast...
my $object = Foo::Bar->new( { foo => 1, bar => 2, baz => 3, } );
Using Object::Tiny...
my $object = Foo::Bar->new( foo => 1, bar => 2, baz => 3, );
Object::Tiny constructors are 110% faster than Class::Accessor::Fast
Object::Tiny accessors are identical in speed to Class::Accessor::Fast accessors, but Object::Tiny constructors are \s-1TWICE\s0 as fast as Class::Accessor::Fast constructors, \s-1DESPITE\s0 C:A:Fast forcing you to pass by reference (which is typically done for speed reasons).
Benchmarking constructor plus accessors... Rate accessor tiny accessor 100949/s -- -45% tiny 182382/s 81% --
Benchmarking constructor alone... Rate accessor tiny accessor 156470/s -- -54% tiny 342231/s 119% --
Benchmarking accessors alone... Rate tiny accessor tiny 81.0/s -- -0% accessor 81.0/s 0% --
Object::Tiny pollutes your \s-1API\s0 95% less than Class::Accessor::Fast
Object::Tiny adds two methods to your class, \*(C`new\*(C' and \*(C`import\*(C'. The \*(C`new\*(C' constructor is so trivial you can just ignore it and use your own if you wish, and the \*(C`import\*(C' will shortcut and do nothing (it is used to implement the "use Object::Tiny qw{ foo bar baz };" syntax itself).
So if you make your own import, you can ignore the Object::Tiny one.
Class::Accessor::Fast isn't quite as light, adding all sorts of useless extra public methods (why on earth would you want to add method accessors at run-time?).
Here's what the classes used in the benchmark end up like.
DB<1> use Class::Inspector
DB<2> x Class::Inspector->methods('Foo_Bar_Tiny'); 0 ARRAY(0xfda780) 0 'bar' 1 'baz' 2 'foo' 3 'import' 4 'new'
DB<3> x Class::Inspector->methods('Foo_Bar_Accessor'); 0 ARRAY(0xfdb3c8) 0 '_bar_accessor' 1 '_baz_accessor' 2 '_carp' 3 '_croak' 4 '_foo_accessor' 5 '_mk_accessors' 6 'accessor_name_for' 7 'bar' 8 'baz' 9 'best_practice_accessor_name_for' 10 'best_practice_mutator_name_for' 11 'follow_best_practice' 12 'foo' 13 'get' 14 'make_accessor' 15 'make_ro_accessor' 16 'make_wo_accessor' 17 'mk_accessors' 18 'mk_ro_accessors' 19 'mk_wo_accessors' 20 'mutator_name_for' 21 'new' 22 'set'
As you can see, Object::Tiny adds 2 methods to your class, Class::Accessor adds 16 methods, plus one extra one for every accessor.
Object::Tiny doesn't have any of the caveats of Class::Accessor::Fast
When you call use Object::Tiny qw{ foo bar baz } it isn't treated as some sort of specification for the class, it's just a list of accessors you want made for you.
So if you want to customize \*(C`foo\*(C' you don't need to get into contortions with \*(L"pure\*(R" base classes or calling alternate internal methods. Just make your own \*(C`foo\*(C' method and remove \*(C`foo\*(C' from the list passed to the \*(C`use\*(C' call.
Object::Tiny is more back-compatible than Class::Accessor::Fast
Class::Accessor::Fast has a minimum Perl dependency of 5.005002.
Object::Tiny has a minimum Perl dependency of 5.004.
Object::Tiny has no module dependencies whatsoever
Object::Tiny does not load \s-1ANYTHING\s0 at all outside of its own single .pm file.
So Object::Tiny will never get confused in odd situations due to old or weird versions of other modules (Class::Accessor::Fast has a dependency on base.pm, which has some caveats of its own).
Bugs should be reported via the \s-1CPAN\s0 bug tracker at
<http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Object-Tiny>
For other issues, contact the author.
Adam Kennedy <[email protected]>
Config::Tiny
Copyright 2007 - 2008 Adam Kennedy.
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 \s-1LICENSE\s0 file included with this module.