This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Use same list of "when to use OO" criteria in perlmodstyle as in perlootut
[perl5.git] / pod / perlobj.pod
CommitLineData
a0d0e21e 1=head1 NAME
d74e8afc 2X<object> X<OOP>
a0d0e21e
LW
3
4perlobj - Perl objects
5
6=head1 DESCRIPTION
7
14218588 8First you need to understand what references are in Perl.
5f05dabc 9See L<perlref> for that. Second, if you still find the following
10reference work too complicated, a tutorial on object-oriented programming
890a53b9 11in Perl can be found in L<perltoot> and L<perltooc>.
a0d0e21e 12
54310121 13If you're still with us, then
5f05dabc 14here are three very simple definitions that you should find reassuring.
a0d0e21e
LW
15
16=over 4
17
18=item 1.
19
20An object is simply a reference that happens to know which class it
21belongs to.
22
23=item 2.
24
25A class is simply a package that happens to provide methods to deal
26with object references.
27
28=item 3.
29
30A method is simply a subroutine that expects an object reference (or
55497cff 31a package name, for class methods) as the first argument.
a0d0e21e
LW
32
33=back
34
35We'll cover these points now in more depth.
36
37=head2 An Object is Simply a Reference
d74e8afc 38X<object> X<bless> X<constructor> X<new>
a0d0e21e
LW
39
40Unlike say C++, Perl doesn't provide any special syntax for
41constructors. A constructor is merely a subroutine that returns a
cb1a09d0 42reference to something "blessed" into a class, generally the
a0d0e21e
LW
43class that the subroutine is defined in. Here is a typical
44constructor:
45
46 package Critter;
47 sub new { bless {} }
48
5a964f20
TC
49That word C<new> isn't special. You could have written
50a construct this way, too:
51
52 package Critter;
53 sub spawn { bless {} }
54
14218588 55This might even be preferable, because the C++ programmers won't
5a964f20
TC
56be tricked into thinking that C<new> works in Perl as it does in C++.
57It doesn't. We recommend that you name your constructors whatever
58makes sense in the context of the problem you're solving. For example,
59constructors in the Tk extension to Perl are named after the widgets
60they create.
61
62One thing that's different about Perl constructors compared with those in
63C++ is that in Perl, they have to allocate their own memory. (The other
64things is that they don't automatically call overridden base-class
65constructors.) The C<{}> allocates an anonymous hash containing no
66key/value pairs, and returns it The bless() takes that reference and
67tells the object it references that it's now a Critter, and returns
68the reference. This is for convenience, because the referenced object
69itself knows that it has been blessed, and the reference to it could
70have been returned directly, like this:
a0d0e21e
LW
71
72 sub new {
73 my $self = {};
74 bless $self;
75 return $self;
76 }
77
14218588 78You often see such a thing in more complicated constructors
a0d0e21e
LW
79that wish to call methods in the class as part of the construction:
80
81 sub new {
5a964f20 82 my $self = {};
a0d0e21e
LW
83 bless $self;
84 $self->initialize();
cb1a09d0
AD
85 return $self;
86 }
87
1fef88e7 88If you care about inheritance (and you should; see
b687b08b 89L<perlmodlib/"Modules: Creation, Use, and Abuse">),
1fef88e7 90then you want to use the two-arg form of bless
cb1a09d0
AD
91so that your constructors may be inherited:
92
93 sub new {
94 my $class = shift;
95 my $self = {};
5a964f20 96 bless $self, $class;
cb1a09d0
AD
97 $self->initialize();
98 return $self;
99 }
100
c47ff5f1 101Or if you expect people to call not just C<< CLASS->new() >> but also
eac7fe86
CP
102C<< $obj->new() >>, then use something like the following. (Note that using
103this to call new() on an instance does not automatically perform any
104copying. If you want a shallow or deep copy of an object, you'll have to
105specifically allow for that.) The initialize() method used will be of
106whatever $class we blessed the object into:
cb1a09d0
AD
107
108 sub new {
109 my $this = shift;
110 my $class = ref($this) || $this;
111 my $self = {};
5a964f20 112 bless $self, $class;
cb1a09d0
AD
113 $self->initialize();
114 return $self;
a0d0e21e
LW
115 }
116
117Within the class package, the methods will typically deal with the
118reference as an ordinary reference. Outside the class package,
119the reference is generally treated as an opaque value that may
5f05dabc 120be accessed only through the class's methods.
a0d0e21e 121
14218588 122Although a constructor can in theory re-bless a referenced object
19799a22
GS
123currently belonging to another class, this is almost certainly going
124to get you into trouble. The new class is responsible for all
125cleanup later. The previous blessing is forgotten, as an object
126may belong to only one class at a time. (Although of course it's
127free to inherit methods from many classes.) If you find yourself
128having to do this, the parent class is probably misbehaving, though.
a0d0e21e
LW
129
130A clarification: Perl objects are blessed. References are not. Objects
131know which package they belong to. References do not. The bless()
5f05dabc 132function uses the reference to find the object. Consider
a0d0e21e
LW
133the following example:
134
135 $a = {};
136 $b = $a;
137 bless $a, BLAH;
138 print "\$b is a ", ref($b), "\n";
139
54310121 140This reports $b as being a BLAH, so obviously bless()
a0d0e21e
LW
141operated on the object and not on the reference.
142
143=head2 A Class is Simply a Package
d74e8afc 144X<class> X<package> X<@ISA> X<inheritance>
a0d0e21e
LW
145
146Unlike say C++, Perl doesn't provide any special syntax for class
5f05dabc 147definitions. You use a package as a class by putting method
a0d0e21e
LW
148definitions into the class.
149
5a964f20 150There is a special array within each package called @ISA, which says
a0d0e21e
LW
151where else to look for a method if you can't find it in the current
152package. This is how Perl implements inheritance. Each element of the
153@ISA array is just the name of another package that happens to be a
dd69841b
BB
154class package. The classes are searched for missing methods in
155depth-first, left-to-right order by default (see L<mro> for alternative
156search order and other in-depth information). The classes accessible
54310121 157through @ISA are known as base classes of the current class.
a0d0e21e 158
5a964f20
TC
159All classes implicitly inherit from class C<UNIVERSAL> as their
160last base class. Several commonly used methods are automatically
003db2bd
RS
161supplied in the UNIVERSAL class; see L<"Default UNIVERSAL methods"> or
162L<UNIVERSAL|UNIVERSAL> for more details.
d74e8afc 163X<UNIVERSAL> X<base class> X<class, base>
5a964f20 164
14218588 165If a missing method is found in a base class, it is cached
a0d0e21e
LW
166in the current class for efficiency. Changing @ISA or defining new
167subroutines invalidates the cache and causes Perl to do the lookup again.
168
5a964f20
TC
169If neither the current class, its named base classes, nor the UNIVERSAL
170class contains the requested method, these three places are searched
171all over again, this time looking for a method named AUTOLOAD(). If an
172AUTOLOAD is found, this method is called on behalf of the missing method,
173setting the package global $AUTOLOAD to be the fully qualified name of
174the method that was intended to be called.
d74e8afc 175X<AUTOLOAD>
5a964f20
TC
176
177If none of that works, Perl finally gives up and complains.
178
ed850460 179If you want to stop the AUTOLOAD inheritance say simply
d74e8afc 180X<AUTOLOAD>
ed850460
JH
181
182 sub AUTOLOAD;
183
184and the call will die using the name of the sub being called.
185
5a964f20
TC
186Perl classes do method inheritance only. Data inheritance is left up
187to the class itself. By and large, this is not a problem in Perl,
188because most classes model the attributes of their object using an
189anonymous hash, which serves as its own little namespace to be carved up
190by the various classes that might want to do something with the object.
191The only problem with this is that you can't sure that you aren't using
192a piece of the hash that isn't already used. A reasonable workaround
193is to prepend your fieldname in the hash with the package name.
d74e8afc 194X<inheritance, method> X<inheritance, data>
5a964f20
TC
195
196 sub bump {
197 my $self = shift;
198 $self->{ __PACKAGE__ . ".count"}++;
199 }
a0d0e21e
LW
200
201=head2 A Method is Simply a Subroutine
d74e8afc 202X<method>
a0d0e21e
LW
203
204Unlike say C++, Perl doesn't provide any special syntax for method
205definition. (It does provide a little syntax for method invocation
206though. More on that later.) A method expects its first argument
19799a22
GS
207to be the object (reference) or package (string) it is being invoked
208on. There are two ways of calling methods, which we'll call class
209methods and instance methods.
a0d0e21e 210
55497cff 211A class method expects a class name as the first argument. It
19799a22
GS
212provides functionality for the class as a whole, not for any
213individual object belonging to the class. Constructors are often
890a53b9 214class methods, but see L<perltoot> and L<perltooc> for alternatives.
19799a22
GS
215Many class methods simply ignore their first argument, because they
216already know what package they're in and don't care what package
5f05dabc 217they were invoked via. (These aren't necessarily the same, because
55497cff 218class methods follow the inheritance tree just like ordinary instance
219methods.) Another typical use for class methods is to look up an
a0d0e21e
LW
220object by name:
221
222 sub find {
223 my ($class, $name) = @_;
224 $objtable{$name};
225 }
226
55497cff 227An instance method expects an object reference as its first argument.
a0d0e21e
LW
228Typically it shifts the first argument into a "self" or "this" variable,
229and then uses that as an ordinary reference.
230
231 sub display {
232 my $self = shift;
233 my @keys = @_ ? @_ : sort keys %$self;
234 foreach $key (@keys) {
235 print "\t$key => $self->{$key}\n";
236 }
237 }
238
239=head2 Method Invocation
d74e8afc 240X<invocation> X<method> X<arrow> X<< -> >>
a0d0e21e 241
5d9f8747
IK
242For various historical and other reasons, Perl offers two equivalent
243ways to write a method call. The simpler and more common way is to use
244the arrow notation:
a0d0e21e 245
5d9f8747
IK
246 my $fred = Critter->find("Fred");
247 $fred->display("Height", "Weight");
a0d0e21e 248
5f7b1de2 249You should already be familiar with the use of the C<< -> >> operator with
5d9f8747
IK
250references. In fact, since C<$fred> above is a reference to an object,
251you could think of the method call as just another form of
252dereferencing.
a0d0e21e 253
5d9f8747
IK
254Whatever is on the left side of the arrow, whether a reference or a
255class name, is passed to the method subroutine as its first argument.
256So the above code is mostly equivalent to:
a0d0e21e 257
5d9f8747
IK
258 my $fred = Critter::find("Critter", "Fred");
259 Critter::display($fred, "Height", "Weight");
a0d0e21e 260
5d9f8747
IK
261How does Perl know which package the subroutine is in? By looking at
262the left side of the arrow, which must be either a package name or a
263reference to an object, i.e. something that has been blessed to a
5f7b1de2 264package. Either way, that's the package where Perl starts looking. If
5d9f8747
IK
265that package has no subroutine with that name, Perl starts looking for
266it in any base classes of that package, and so on.
a0d0e21e 267
5f7b1de2 268If you need to, you I<can> force Perl to start looking in some other package:
a0d0e21e 269
5d9f8747
IK
270 my $barney = MyCritter->Critter::find("Barney");
271 $barney->Critter::display("Height", "Weight");
a0d0e21e 272
5d9f8747
IK
273Here C<MyCritter> is presumably a subclass of C<Critter> that defines
274its own versions of find() and display(). We haven't specified what
275those methods do, but that doesn't matter above since we've forced Perl
276to start looking for the subroutines in C<Critter>.
a0d0e21e 277
5d9f8747 278As a special case of the above, you may use the C<SUPER> pseudo-class to
5f7b1de2
JH
279tell Perl to start looking for the method in the packages named in the
280current class's C<@ISA> list.
d74e8afc 281X<SUPER>
a0d0e21e 282
5d9f8747
IK
283 package MyCritter;
284 use base 'Critter'; # sets @MyCritter::ISA = ('Critter');
a0d0e21e 285
5d9f8747
IK
286 sub display {
287 my ($self, @args) = @_;
288 $self->SUPER::display("Name", @args);
289 }
a0d0e21e 290
50506ccd
DM
291It is important to note that C<SUPER> refers to the superclass(es) of the
292I<current package> and not to the superclass(es) of the object. Also, the
029f3b44
DM
293C<SUPER> pseudo-class can only currently be used as a modifier to a method
294name, but not in any of the other ways that class names are normally used,
295eg:
d74e8afc 296X<SUPER>
029f3b44
DM
297
298 something->SUPER::method(...); # OK
299 SUPER::method(...); # WRONG
300 SUPER->method(...); # WRONG
301
5d9f8747
IK
302Instead of a class name or an object reference, you can also use any
303expression that returns either of those on the left side of the arrow.
304So the following statement is valid:
a0d0e21e 305
5d9f8747 306 Critter->find("Fred")->display("Height", "Weight");
a0d0e21e 307
5f7b1de2 308and so is the following:
cb1a09d0 309
5d9f8747 310 my $fred = (reverse "rettirC")->find(reverse "derF");
cb1a09d0 311
d9693f5a
SP
312The right side of the arrow typically is the method name, but a simple
313scalar variable containing either the method name or a subroutine
314reference can also be used.
315
e947c198
IG
316If the right side of the arrow is a scalar containing a reference
317to a subroutine, then this is equivalent to calling the referenced
318subroutine directly with the class name or object on the left side
319of the arrow as its first argument. No lookup is done and there is
320no requirement that the subroutine be defined in any package related
321to the class name or object on the left side of the arrow.
322
323For example, the following calls to $display are equivalent:
324
325 my $display = sub { my $self = shift; ... };
326 $fred->$display("Height", "Weight");
327 $display->($fred, "Height", "Weight");
328
5d9f8747 329=head2 Indirect Object Syntax
d74e8afc 330X<indirect object syntax> X<invocation, indirect> X<indirect>
cb1a09d0 331
5f7b1de2
JH
332The other way to invoke a method is by using the so-called "indirect
333object" notation. This syntax was available in Perl 4 long before
334objects were introduced, and is still used with filehandles like this:
748a9306 335
5d9f8747 336 print STDERR "help!!!\n";
19799a22 337
5d9f8747 338The same syntax can be used to call either object or class methods.
19799a22 339
5d9f8747
IK
340 my $fred = find Critter "Fred";
341 display $fred "Height", "Weight";
19799a22 342
5d9f8747
IK
343Notice that there is no comma between the object or class name and the
344parameters. This is how Perl can tell you want an indirect method call
345instead of an ordinary subroutine call.
19799a22 346
5d9f8747 347But what if there are no arguments? In that case, Perl must guess what
5f7b1de2
JH
348you want. Even worse, it must make that guess I<at compile time>.
349Usually Perl gets it right, but when it doesn't you get a function
350call compiled as a method, or vice versa. This can introduce subtle bugs
351that are hard to detect.
5d9f8747 352
ac036724 353For example, a call to a method C<new> in indirect notation (as C++
354programmers are wont to make) can be miscompiled into a subroutine
5d9f8747
IK
355call if there's already a C<new> function in scope. You'd end up
356calling the current package's C<new> as a subroutine, rather than the
357desired class's method. The compiler tries to cheat by remembering
5f7b1de2
JH
358bareword C<require>s, but the grief when it messes up just isn't worth the
359years of debugging it will take you to track down such subtle bugs.
5d9f8747
IK
360
361There is another problem with this syntax: the indirect object is
362limited to a name, a scalar variable, or a block, because it would have
363to do too much lookahead otherwise, just like any other postfix
364dereference in the language. (These are the same quirky rules as are
365used for the filehandle slot in functions like C<print> and C<printf>.)
366This can lead to horribly confusing precedence problems, as in these
367next two lines:
19799a22
GS
368
369 move $obj->{FIELD}; # probably wrong!
370 move $ary[$i]; # probably wrong!
371
372Those actually parse as the very surprising:
373
374 $obj->move->{FIELD}; # Well, lookee here
4f298f32 375 $ary->move([$i]); # Didn't expect this one, eh?
19799a22
GS
376
377Rather than what you might have expected:
378
379 $obj->{FIELD}->move(); # You should be so lucky.
380 $ary[$i]->move; # Yeah, sure.
381
5d9f8747
IK
382To get the correct behavior with indirect object syntax, you would have
383to use a block around the indirect object:
19799a22 384
5d9f8747
IK
385 move {$obj->{FIELD}};
386 move {$ary[$i]};
387
388Even then, you still have the same potential problem if there happens to
389be a function named C<move> in the current package. B<The C<< -> >>
390notation suffers from neither of these disturbing ambiguities, so we
391recommend you use it exclusively.> However, you may still end up having
392to read code using the indirect object notation, so it's important to be
393familiar with it.
748a9306 394
a2bdc9a5 395=head2 Default UNIVERSAL methods
d74e8afc 396X<UNIVERSAL>
a2bdc9a5 397
398The C<UNIVERSAL> package automatically contains the following methods that
399are inherited by all other classes:
400
401=over 4
402
71be2cbc 403=item isa(CLASS)
d74e8afc 404X<isa>
a2bdc9a5 405
68dc0745 406C<isa> returns I<true> if its object is blessed into a subclass of C<CLASS>
a2bdc9a5 407
bcb8f0e8 408=item DOES(ROLE)
003db2bd 409X<DOES>
bcb8f0e8 410
003db2bd
RS
411C<DOES> returns I<true> if its object claims to perform the role C<ROLE>. By
412default, this is equivalent to C<isa>.
bcb8f0e8 413
71be2cbc 414=item can(METHOD)
d74e8afc 415X<can>
a2bdc9a5 416
417C<can> checks to see if its object has a method called C<METHOD>,
418if it does then a reference to the sub is returned, if it does not then
003db2bd 419C<undef> is returned.
b32b0a5d 420
71be2cbc 421=item VERSION( [NEED] )
d74e8afc 422X<VERSION>
760ac839 423
71be2cbc 424C<VERSION> returns the version number of the class (package). If the
425NEED argument is given then it will check that the current version (as
426defined by the $VERSION variable in the given package) not less than
003db2bd
RS
427NEED; it will die if this is not the case. This method is called automatically
428by the C<VERSION> form of C<use>.
a2bdc9a5 429
003db2bd 430 use Package 1.2 qw(some imported subs);
71be2cbc 431 # implies:
003db2bd 432 Package->VERSION(1.2);
a2bdc9a5 433
a2bdc9a5 434=back
435
54310121 436=head2 Destructors
d74e8afc 437X<destructor> X<DESTROY>
a0d0e21e
LW
438
439When the last reference to an object goes away, the object is
440automatically destroyed. (This may even be after you exit, if you've
441stored references in global variables.) If you want to capture control
442just before the object is freed, you may define a DESTROY method in
443your class. It will automatically be called at the appropriate moment,
4e8e7886
GS
444and you can do any extra cleanup you need to do. Perl passes a reference
445to the object under destruction as the first (and only) argument. Beware
446that the reference is a read-only value, and cannot be modified by
447manipulating C<$_[0]> within the destructor. The object itself (i.e.
448the thingy the reference points to, namely C<${$_[0]}>, C<@{$_[0]}>,
449C<%{$_[0]}> etc.) is not similarly constrained.
450
f4551fcd
MG
451Since DESTROY methods can be called at unpredictable times, it is
452important that you localise any global variables that the method may
453update. In particular, localise C<$@> if you use C<eval {}> and
454localise C<$?> if you use C<system> or backticks.
455
4e8e7886
GS
456If you arrange to re-bless the reference before the destructor returns,
457perl will again call the DESTROY method for the re-blessed object after
458the current one returns. This can be used for clean delegation of
459object destruction, or for ensuring that destructors in the base classes
460of your choosing get called. Explicitly calling DESTROY is also possible,
461but is usually never needed.
462
a35666c6
NC
463DESTROY is subject to AUTOLOAD lookup, just like any other method. Hence, if
464your class has an AUTOLOAD method, but does not need any DESTROY actions,
465you probably want to provide a DESTROY method anyway, to prevent an
466expensive call to AUTOLOAD each time an object is freed. As this technique
467makes empty DESTROY methods common, the implementation is optimised so that
468a DESTROY method that is an empty or constant subroutine, and hence could
469have no side effects anyway, is not actually called.
470X<AUTOLOAD> X<DESTROY>
471
14218588 472Do not confuse the previous discussion with how objects I<CONTAINED> in the current
4e8e7886
GS
473one are destroyed. Such objects will be freed and destroyed automatically
474when the current object is freed, provided no other references to them exist
475elsewhere.
a0d0e21e
LW
476
477=head2 Summary
478
5f05dabc 479That's about all there is to it. Now you need just to go off and buy a
a0d0e21e
LW
480book about object-oriented design methodology, and bang your forehead
481with it for the next six months or so.
482
cb1a09d0 483=head2 Two-Phased Garbage Collection
d74e8afc
ITB
484X<garbage collection> X<GC> X<circular reference>
485X<reference, circular> X<DESTROY> X<destructor>
cb1a09d0 486
14218588
GS
487For most purposes, Perl uses a fast and simple, reference-based
488garbage collection system. That means there's an extra
cb1a09d0
AD
489dereference going on at some level, so if you haven't built
490your Perl executable using your C compiler's C<-O> flag, performance
491will suffer. If you I<have> built Perl with C<cc -O>, then this
492probably won't matter.
493
494A more serious concern is that unreachable memory with a non-zero
495reference count will not normally get freed. Therefore, this is a bad
54310121 496idea:
cb1a09d0
AD
497
498 {
499 my $a;
500 $a = \$a;
54310121 501 }
cb1a09d0
AD
502
503Even thought $a I<should> go away, it can't. When building recursive data
504structures, you'll have to break the self-reference yourself explicitly
505if you don't care to leak. For example, here's a self-referential
506node such as one might use in a sophisticated tree structure:
507
508 sub new_node {
eac7fe86
CP
509 my $class = shift;
510 my $node = {};
cb1a09d0
AD
511 $node->{LEFT} = $node->{RIGHT} = $node;
512 $node->{DATA} = [ @_ ];
513 return bless $node => $class;
54310121 514 }
cb1a09d0
AD
515
516If you create nodes like that, they (currently) won't go away unless you
517break their self reference yourself. (In other words, this is not to be
518construed as a feature, and you shouldn't depend on it.)
519
520Almost.
521
522When an interpreter thread finally shuts down (usually when your program
523exits), then a rather costly but complete mark-and-sweep style of garbage
524collection is performed, and everything allocated by that thread gets
525destroyed. This is essential to support Perl as an embedded or a
54310121 526multithreadable language. For example, this program demonstrates Perl's
cb1a09d0
AD
527two-phased garbage collection:
528
54310121 529 #!/usr/bin/perl
cb1a09d0
AD
530 package Subtle;
531
532 sub new {
533 my $test;
534 $test = \$test;
535 warn "CREATING " . \$test;
536 return bless \$test;
54310121 537 }
cb1a09d0
AD
538
539 sub DESTROY {
540 my $self = shift;
541 warn "DESTROYING $self";
54310121 542 }
cb1a09d0
AD
543
544 package main;
545
546 warn "starting program";
547 {
548 my $a = Subtle->new;
549 my $b = Subtle->new;
550 $$a = 0; # break selfref
551 warn "leaving block";
54310121 552 }
cb1a09d0
AD
553
554 warn "just exited block";
555 warn "time to die...";
556 exit;
557
2359510d
SD
558When run as F</foo/test>, the following output is produced:
559
560 starting program at /foo/test line 18.
561 CREATING SCALAR(0x8e5b8) at /foo/test line 7.
562 CREATING SCALAR(0x8e57c) at /foo/test line 7.
563 leaving block at /foo/test line 23.
564 DESTROYING Subtle=SCALAR(0x8e5b8) at /foo/test line 13.
565 just exited block at /foo/test line 26.
566 time to die... at /foo/test line 27.
cb1a09d0
AD
567 DESTROYING Subtle=SCALAR(0x8e57c) during global destruction.
568
569Notice that "global destruction" bit there? That's the thread
54310121 570garbage collector reaching the unreachable.
cb1a09d0 571
14218588
GS
572Objects are always destructed, even when regular refs aren't. Objects
573are destructed in a separate pass before ordinary refs just to
cb1a09d0 574prevent object destructors from using refs that have been themselves
5f05dabc 575destructed. Plain refs are only garbage-collected if the destruct level
cb1a09d0
AD
576is greater than 0. You can test the higher levels of global destruction
577by setting the PERL_DESTRUCT_LEVEL environment variable, presuming
578C<-DDEBUGGING> was enabled during perl build time.
96090e4f 579See L<perlhacktips/PERL_DESTRUCT_LEVEL> for more information.
cb1a09d0
AD
580
581A more complete garbage collection strategy will be implemented
582at a future date.
583
5a964f20
TC
584In the meantime, the best solution is to create a non-recursive container
585class that holds a pointer to the self-referential data structure.
586Define a DESTROY method for the containing object's class that manually
587breaks the circularities in the self-referential structure.
588
a0d0e21e
LW
589=head1 SEE ALSO
590
8257a158 591A kinder, gentler tutorial on object-oriented programming in Perl can
890a53b9 592be found in L<perltoot>, L<perlboot> and L<perltooc>. You should
8257a158
MS
593also check out L<perlbot> for other object tricks, traps, and tips, as
594well as L<perlmodlib> for some style guides on constructing both
595modules and classes.