1Object::Tiny(3) User Contributed Perl Documentation Object::Tiny(3)
2
6 Object::Tiny - Class building as simple as it gets
7
9 # Define a class
10 package Foo;
11 use Object::Tiny qw{ bar baz };
13 1;
15 # Use the class
18 my $object = Foo->new( bar => 1 );
19 print "bar is " . $object->bar . "\n";
21
23 There's a whole bunch of class builders out there. In fact, creating a
24 class builder seems to be something of a rite of passage (this is my
25 fifth, at least).
26 Unfortunately, most of the time I want a class builder I'm in a hurry
28 and sketching out lots of fairly simple data classes with fairly simple
29 structure, mostly just read-only accessors, and that's about it.
30 Often this is for code that won't end up on CPAN, so adding a small
32 dependency doesn't matter much. I just want to be able to define these
33 classes FAST.
34 By which I mean LESS typing than writing them by hand, not more. And I
36 don't need all those weird complex features that bloat out the code and
37 take over the whole way I build modules.
38 And so, I present yet another member of the Tiny family of modules,
40 Object::Tiny.
41 The goal here is really just to save me some typing. There's others
43 that could do the job just fine, but I want something that does as
44 little as possible and creates code the same way I'd have written it by
45 hand anyway.
46 To use Object::Tiny, just call it with a list of accessors to be
48 created.
49 use Object::Tiny 'foo', 'bar';
51 For a large list, I lay it out like this...
53 use Object::Tiny qw{
55 item_font_face
56 item_font_color
57 item_font_size
58 item_text_content
59 item_display_time
60 seperator_font_face
61 seperator_font_color
62 seperator_font_size
63 seperator_text_content
64 };
65 This will create a bunch of simple accessors, and set the inheritance
67 to be the child of Object::Tiny.
68 Object::Tiny is empty other than a basic "new" constructor which does
70 the following
71 sub new {
73 my $class = shift;
74 return bless { @_ }, $class;
75 }
76 In fact, if doing the following in your class gets annoying...
78 sub new {
80 my $class = shift;
81 my $self = $class->SUPER::new( @_ );
82 # Extra checking and such
84 ...
85 return $self;
87 }
88 ... then feel free to ditch the SUPER call and just create the hash
90 yourself! It's not going to make a lick of different and there's
91 nothing magic going on under the covers you might break.
92 And that's really all there is to it. Let a million simple data classes
94 bloom. Features? We don't need no stinking features.
95 Handling Subclasses
97 If the class you are using Object::Tiny for is already a subclass of
98 another Object::Tiny class (or a subclass of anything else) it doesn't
99 really work to make the class use multiple inheritance.
100 So in this case, Object::Tiny will create the accessors you specify,
102 but WON'T make it a subclass of Object::Tiny.
103 Why bother when Class::Accessor::* already does the same thing?
105 As a class builder, Object::Tiny inevitably is compared to
106 Class::Accessor and related modules. They seem so similar, so why would
107 I reimplement it?
108 The answer is that for experienced developers that don't need or want
110 hand-holding, Object::Tiny is just outright better, faster or cheaper
111 on every single metric than Class::Accessor::Fast, which is the most
112 comparable member of the Class::Accessor::* family.
113 Object::Tiny is 93% smaller than Class::Accessor::Fast
115 Class::Accessor::Fast requires about 125k of memory to load.
117 Object::Tiny requires about 8k of memory to load.
119 Object::Tiny is 75% more terse to use than Class::Accessor::Fast
121 Object::Tiny is used with the least possible number of keystrokes
123 (short of making the actual name Object::Tiny smaller).
124 And it requires no ugly constructor methods.
126 I mean really, what sort of a method name is 'mk_ro_accessors'. That
128 sort of thing went out of style in the early nineties.
129 Using Class::Accessor::Fast...
131 package Foo::Bar;
133 use base 'Class::Accessor::Fast';
134 Foo::Bar->mk_ro_accessors(qw{ foo bar baz });
135 Using Object::Tiny...
137 package Foo::Bar;
139 use Object::Tiny qw{ foo bar baz };
140 Further, Object::Tiny lets you pass your params in directly, without
142 having to wrap them in an additional HASH reference that will just be
143 copied ANYWAY inside the constructor.
144 Using Class::Accessor::Fast...
146 my $object = Foo::Bar->new( {
148 foo => 1,
149 bar => 2,
150 baz => 3,
151 } );
152 Using Object::Tiny...
154 my $object = Foo::Bar->new(
156 foo => 1,
157 bar => 2,
158 baz => 3,
159 );
160 Object::Tiny constructors are 110% faster than Class::Accessor::Fast
162 Object::Tiny accessors are identical in speed to Class::Accessor::Fast
164 accessors, but Object::Tiny constructors are TWICE as fast as
165 Class::Accessor::Fast constructors, DESPITE C:A:Fast forcing you to
166 pass by reference (which is typically done for speed reasons).
167 Benchmarking constructor plus accessors...
169 Rate accessor tiny
170 accessor 100949/s -- -45%
171 tiny 182382/s 81% --
172 Benchmarking constructor alone...
174 Rate accessor tiny
175 accessor 156470/s -- -54%
176 tiny 342231/s 119% --
177 Benchmarking accessors alone...
179 Rate tiny accessor
180 tiny 81.0/s -- -0%
181 accessor 81.0/s 0% --
182 Object::Tiny pollutes your API 95% less than Class::Accessor::Fast
184 Object::Tiny adds two methods to your class, "new" and "import". The
186 "new" constructor is so trivial you can just ignore it and use your own
187 if you wish, and the "import" will shortcut and do nothing (it is used
188 to implement the "use Object::Tiny qw{ foo bar baz };" syntax itself).
189 So if you make your own import, you can ignore the Object::Tiny one.
191 Class::Accessor::Fast isn't quite as light, adding all sorts of useless
193 extra public methods (why on earth would you want to add method
194 accessors at run-time?).
195 Here's what the classes used in the benchmark end up like.
197 DB<1> use Class::Inspector
199 DB<2> x Class::Inspector->methods('Foo_Bar_Tiny');
201 0 ARRAY(0xfda780)
202 0 'bar'
203 1 'baz'
204 2 'foo'
205 3 'import'
206 4 'new'
207 DB<3> x Class::Inspector->methods('Foo_Bar_Accessor');
209 0 ARRAY(0xfdb3c8)
210 0 '_bar_accessor'
211 1 '_baz_accessor'
212 2 '_carp'
213 3 '_croak'
214 4 '_foo_accessor'
215 5 '_mk_accessors'
216 6 'accessor_name_for'
217 7 'bar'
218 8 'baz'
219 9 'best_practice_accessor_name_for'
220 10 'best_practice_mutator_name_for'
221 11 'follow_best_practice'
222 12 'foo'
223 13 'get'
224 14 'make_accessor'
225 15 'make_ro_accessor'
226 16 'make_wo_accessor'
227 17 'mk_accessors'
228 18 'mk_ro_accessors'
229 19 'mk_wo_accessors'
230 20 'mutator_name_for'
231 21 'new'
232 22 'set'
233 As you can see, Object::Tiny adds 2 methods to your class,
235 Class::Accessor adds 16 methods, plus one extra one for every accessor.
236 Object::Tiny doesn't have any of the caveats of Class::Accessor::Fast
238 When you call use Object::Tiny qw{ foo bar baz } it isn't treated as
240 some sort of specification for the class, it's just a list of accessors
241 you want made for you.
242 So if you want to customize "foo" you don't need to get into
244 contortions with "pure" base classes or calling alternate internal
245 methods. Just make your own "foo" method and remove "foo" from the list
246 passed to the "use" call.
247 Object::Tiny is more back-compatible than Class::Accessor::Fast
249 Class::Accessor::Fast has a minimum Perl dependency of 5.005002.
251 Object::Tiny has a minimum Perl dependency of 5.004.
253 Object::Tiny has no module dependencies whatsoever
255 Object::Tiny does not load ANYTHING at all outside of its own single
257 .pm file.
258 So Object::Tiny will never get confused in odd situations due to old or
260 weird versions of other modules (Class::Accessor::Fast has a dependency
261 on base.pm, which has some caveats of its own).
262
264 Bugs should be reported via the CPAN bug tracker at
265 <http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Object-Tiny>
267 For other issues, contact the author.
269
271 Adam Kennedy <adamk@cpan.org>
272
274 Config::Tiny
275
277 Copyright 2007 - 2011 Adam Kennedy.
278 This program is free software; you can redistribute it and/or modify it
280 under the same terms as Perl itself.
281 The full text of the license can be found in the LICENSE file included
283 with this module.
284perl v5.28.0 2018-11-10 Object::Tiny(3)