1PERLDSC(1) Perl Programmers Reference Guide PERLDSC(1)
2
6 perldsc - Perl Data Structures Cookbook
7
9 The single feature most sorely lacking in the Perl programming language
10 prior to its 5.0 release was complex data structures. Even without
11 direct language support, some valiant programmers did manage to emulate
12 them, but it was hard work and not for the faint of heart. You could
13 occasionally get away with the $m{$AoA,$b} notation borrowed from awk
14 in which the keys are actually more like a single concatenated string
15 "$AoA$b", but traversal and sorting were difficult. More desperate
16 programmers even hacked Perl's internal symbol table directly, a
17 strategy that proved hard to develop and maintain--to put it mildly.
18 The 5.0 release of Perl let us have complex data structures. You may
20 now write something like this and all of a sudden, you'd have an array
21 with three dimensions!
22 for $x (1 .. 10) {
24 for $y (1 .. 10) {
25 for $z (1 .. 10) {
26 $AoA[$x][$y][$z] =
27 $x ** $y + $z;
28 }
29 }
30 }
31 Alas, however simple this may appear, underneath it's a much more
33 elaborate construct than meets the eye!
34 How do you print it out? Why can't you say just "print @AoA"? How do
36 you sort it? How can you pass it to a function or get one of these
37 back from a function? Is it an object? Can you save it to disk to
38 read back later? How do you access whole rows or columns of that
39 matrix? Do all the values have to be numeric?
40 As you see, it's quite easy to become confused. While some small
42 portion of the blame for this can be attributed to the reference-based
43 implementation, it's really more due to a lack of existing
44 documentation with examples designed for the beginner.
45 This document is meant to be a detailed but understandable treatment of
47 the many different sorts of data structures you might want to develop.
48 It should also serve as a cookbook of examples. That way, when you
49 need to create one of these complex data structures, you can just
50 pinch, pilfer, or purloin a drop-in example from here.
51 Let's look at each of these possible constructs in detail. There are
53 separate sections on each of the following:
54 · arrays of arrays
56 · hashes of arrays
58 · arrays of hashes
60 · hashes of hashes
62 · more elaborate constructs
64 But for now, let's look at general issues common to all these types of
66 data structures.
67
69 The most important thing to understand about all data structures in
70 Perl--including multidimensional arrays--is that even though they might
71 appear otherwise, Perl @ARRAYs and %HASHes are all internally one-
72 dimensional. They can hold only scalar values (meaning a string,
73 number, or a reference). They cannot directly contain other arrays or
74 hashes, but instead contain references to other arrays or hashes.
75 You can't use a reference to an array or hash in quite the same way
77 that you would a real array or hash. For C or C++ programmers unused
78 to distinguishing between arrays and pointers to the same, this can be
79 confusing. If so, just think of it as the difference between a
80 structure and a pointer to a structure.
81 You can (and should) read more about references in the perlref(1) man
83 page. Briefly, references are rather like pointers that know what they
84 point to. (Objects are also a kind of reference, but we won't be
85 needing them right away--if ever.) This means that when you have
86 something which looks to you like an access to a two-or-more-
87 dimensional array and/or hash, what's really going on is that the base
88 type is merely a one-dimensional entity that contains references to the
89 next level. It's just that you can use it as though it were a two-
90 dimensional one. This is actually the way almost all C
91 multidimensional arrays work as well.
92 $array[7][12] # array of arrays
94 $array[7]{string} # array of hashes
95 $hash{string}[7] # hash of arrays
96 $hash{string}{'another string'} # hash of hashes
97 Now, because the top level contains only references, if you try to
99 print out your array in with a simple print() function, you'll get
100 something that doesn't look very nice, like this:
101 @AoA = ( [2, 3], [4, 5, 7], [0] );
103 print $AoA[1][2];
104 7
105 print @AoA;
106 ARRAY(0x83c38)ARRAY(0x8b194)ARRAY(0x8b1d0)
107 That's because Perl doesn't (ever) implicitly dereference your
109 variables. If you want to get at the thing a reference is referring
110 to, then you have to do this yourself using either prefix typing
111 indicators, like "${$blah}", "@{$blah}", "@{$blah[$i]}", or else
112 postfix pointer arrows, like "$a->[3]", "$h->{fred}", or even
113 "$ob->method()->[3]".
114
116 The two most common mistakes made in constructing something like an
117 array of arrays is either accidentally counting the number of elements
118 or else taking a reference to the same memory location repeatedly.
119 Here's the case where you just get the count instead of a nested array:
120 for $i (1..10) {
122 @array = somefunc($i);
123 $AoA[$i] = @array; # WRONG!
124 }
125 That's just the simple case of assigning an array to a scalar and
127 getting its element count. If that's what you really and truly want,
128 then you might do well to consider being a tad more explicit about it,
129 like this:
130 for $i (1..10) {
132 @array = somefunc($i);
133 $counts[$i] = scalar @array;
134 }
135 Here's the case of taking a reference to the same memory location again
137 and again:
138 for $i (1..10) {
140 @array = somefunc($i);
141 $AoA[$i] = \@array; # WRONG!
142 }
143 So, what's the big problem with that? It looks right, doesn't it?
145 After all, I just told you that you need an array of references, so by
146 golly, you've made me one!
147 Unfortunately, while this is true, it's still broken. All the
149 references in @AoA refer to the very same place, and they will
150 therefore all hold whatever was last in @array! It's similar to the
151 problem demonstrated in the following C program:
152 #include <pwd.h>
154 main() {
155 struct passwd *getpwnam(), *rp, *dp;
156 rp = getpwnam("root");
157 dp = getpwnam("daemon");
158 printf("daemon name is %s\nroot name is %s\n",
160 dp->pw_name, rp->pw_name);
161 }
162 Which will print
164 daemon name is daemon
166 root name is daemon
167 The problem is that both "rp" and "dp" are pointers to the same
169 location in memory! In C, you'd have to remember to malloc() yourself
170 some new memory. In Perl, you'll want to use the array constructor
171 "[]" or the hash constructor "{}" instead. Here's the right way to do
172 the preceding broken code fragments:
173 for $i (1..10) {
175 @array = somefunc($i);
176 $AoA[$i] = [ @array ];
177 }
178 The square brackets make a reference to a new array with a copy of
180 what's in @array at the time of the assignment. This is what you want.
181 Note that this will produce something similar, but it's much harder to
183 read:
184 for $i (1..10) {
186 @array = 0 .. $i;
187 @{$AoA[$i]} = @array;
188 }
189 Is it the same? Well, maybe so--and maybe not. The subtle difference
191 is that when you assign something in square brackets, you know for sure
192 it's always a brand new reference with a new copy of the data.
193 Something else could be going on in this new case with the
194 "@{$AoA[$i]}" dereference on the left-hand-side of the assignment. It
195 all depends on whether $AoA[$i] had been undefined to start with, or
196 whether it already contained a reference. If you had already populated
197 @AoA with references, as in
198 $AoA[3] = \@another_array;
200 Then the assignment with the indirection on the left-hand-side would
202 use the existing reference that was already there:
203 @{$AoA[3]} = @array;
205 Of course, this would have the "interesting" effect of clobbering
207 @another_array. (Have you ever noticed how when a programmer says
208 something is "interesting", that rather than meaning "intriguing",
209 they're disturbingly more apt to mean that it's "annoying",
210 "difficult", or both? :-)
211 So just remember always to use the array or hash constructors with "[]"
213 or "{}", and you'll be fine, although it's not always optimally
214 efficient.
215 Surprisingly, the following dangerous-looking construct will actually
217 work out fine:
218 for $i (1..10) {
220 my @array = somefunc($i);
221 $AoA[$i] = \@array;
222 }
223 That's because my() is more of a run-time statement than it is a
225 compile-time declaration per se. This means that the my() variable is
226 remade afresh each time through the loop. So even though it looks as
227 though you stored the same variable reference each time, you actually
228 did not! This is a subtle distinction that can produce more efficient
229 code at the risk of misleading all but the most experienced of
230 programmers. So I usually advise against teaching it to beginners. In
231 fact, except for passing arguments to functions, I seldom like to see
232 the gimme-a-reference operator (backslash) used much at all in code.
233 Instead, I advise beginners that they (and most of the rest of us)
234 should try to use the much more easily understood constructors "[]" and
235 "{}" instead of relying upon lexical (or dynamic) scoping and hidden
236 reference-counting to do the right thing behind the scenes.
237 In summary:
239 $AoA[$i] = [ @array ]; # usually best
241 $AoA[$i] = \@array; # perilous; just how my() was that array?
242 @{ $AoA[$i] } = @array; # way too tricky for most programmers
243
245 Speaking of things like "@{$AoA[$i]}", the following are actually the
246 same thing:
247 $aref->[2][2] # clear
249 $$aref[2][2] # confusing
250 That's because Perl's precedence rules on its five prefix dereferencers
252 (which look like someone swearing: "$ @ * % &") make them bind more
253 tightly than the postfix subscripting brackets or braces! This will no
254 doubt come as a great shock to the C or C++ programmer, who is quite
255 accustomed to using *a[i] to mean what's pointed to by the i'th element
256 of "a". That is, they first take the subscript, and only then
257 dereference the thing at that subscript. That's fine in C, but this
258 isn't C.
259 The seemingly equivalent construct in Perl, $$aref[$i] first does the
261 deref of $aref, making it take $aref as a reference to an array, and
262 then dereference that, and finally tell you the i'th value of the array
263 pointed to by $AoA. If you wanted the C notion, you'd have to write
264 "${$AoA[$i]}" to force the $AoA[$i] to get evaluated first before the
265 leading "$" dereferencer.
266
268 If this is starting to sound scarier than it's worth, relax. Perl has
269 some features to help you avoid its most common pitfalls. The best way
270 to avoid getting confused is to start every program like this:
271 #!/usr/bin/perl -w
273 use strict;
274 This way, you'll be forced to declare all your variables with my() and
276 also disallow accidental "symbolic dereferencing". Therefore if you'd
277 done this:
278 my $aref = [
280 [ "fred", "barney", "pebbles", "bambam", "dino", ],
281 [ "homer", "bart", "marge", "maggie", ],
282 [ "george", "jane", "elroy", "judy", ],
283 ];
284 print $aref[2][2];
286 The compiler would immediately flag that as an error at compile time,
288 because you were accidentally accessing @aref, an undeclared variable,
289 and it would thereby remind you to write instead:
290 print $aref->[2][2]
292
294 Before version 5.002, the standard Perl debugger didn't do a very nice
295 job of printing out complex data structures. With 5.002 or above, the
296 debugger includes several new features, including command line editing
297 as well as the "x" command to dump out complex data structures. For
298 example, given the assignment to $AoA above, here's the debugger
299 output:
300 DB<1> x $AoA
302 $AoA = ARRAY(0x13b5a0)
303 0 ARRAY(0x1f0a24)
304 0 'fred'
305 1 'barney'
306 2 'pebbles'
307 3 'bambam'
308 4 'dino'
309 1 ARRAY(0x13b558)
310 0 'homer'
311 1 'bart'
312 2 'marge'
313 3 'maggie'
314 2 ARRAY(0x13b540)
315 0 'george'
316 1 'jane'
317 2 'elroy'
318 3 'judy'
319
321 Presented with little comment (these will get their own manpages
322 someday) here are short code examples illustrating access of various
323 types of data structures.
324
326 Declaration of an ARRAY OF ARRAYS
327 @AoA = (
328 [ "fred", "barney" ],
329 [ "george", "jane", "elroy" ],
330 [ "homer", "marge", "bart" ],
331 );
332 Generation of an ARRAY OF ARRAYS
334 # reading from file
335 while ( <> ) {
336 push @AoA, [ split ];
337 }
338 # calling a function
340 for $i ( 1 .. 10 ) {
341 $AoA[$i] = [ somefunc($i) ];
342 }
343 # using temp vars
345 for $i ( 1 .. 10 ) {
346 @tmp = somefunc($i);
347 $AoA[$i] = [ @tmp ];
348 }
349 # add to an existing row
351 push @{ $AoA[0] }, "wilma", "betty";
352 Access and Printing of an ARRAY OF ARRAYS
354 # one element
355 $AoA[0][0] = "Fred";
356 # another element
358 $AoA[1][1] =~ s/(\w)/\u$1/;
359 # print the whole thing with refs
361 for $aref ( @AoA ) {
362 print "\t [ @$aref ],\n";
363 }
364 # print the whole thing with indices
366 for $i ( 0 .. $#AoA ) {
367 print "\t [ @{$AoA[$i]} ],\n";
368 }
369 # print the whole thing one at a time
371 for $i ( 0 .. $#AoA ) {
372 for $j ( 0 .. $#{ $AoA[$i] } ) {
373 print "elt $i $j is $AoA[$i][$j]\n";
374 }
375 }
376
378 Declaration of a HASH OF ARRAYS
379 %HoA = (
380 flintstones => [ "fred", "barney" ],
381 jetsons => [ "george", "jane", "elroy" ],
382 simpsons => [ "homer", "marge", "bart" ],
383 );
384 Generation of a HASH OF ARRAYS
386 # reading from file
387 # flintstones: fred barney wilma dino
388 while ( <> ) {
389 next unless s/^(.*?):\s*//;
390 $HoA{$1} = [ split ];
391 }
392 # reading from file; more temps
394 # flintstones: fred barney wilma dino
395 while ( $line = <> ) {
396 ($who, $rest) = split /:\s*/, $line, 2;
397 @fields = split ' ', $rest;
398 $HoA{$who} = [ @fields ];
399 }
400 # calling a function that returns a list
402 for $group ( "simpsons", "jetsons", "flintstones" ) {
403 $HoA{$group} = [ get_family($group) ];
404 }
405 # likewise, but using temps
407 for $group ( "simpsons", "jetsons", "flintstones" ) {
408 @members = get_family($group);
409 $HoA{$group} = [ @members ];
410 }
411 # append new members to an existing family
413 push @{ $HoA{"flintstones"} }, "wilma", "betty";
414 Access and Printing of a HASH OF ARRAYS
416 # one element
417 $HoA{flintstones}[0] = "Fred";
418 # another element
420 $HoA{simpsons}[1] =~ s/(\w)/\u$1/;
421 # print the whole thing
423 foreach $family ( keys %HoA ) {
424 print "$family: @{ $HoA{$family} }\n"
425 }
426 # print the whole thing with indices
428 foreach $family ( keys %HoA ) {
429 print "family: ";
430 foreach $i ( 0 .. $#{ $HoA{$family} } ) {
431 print " $i = $HoA{$family}[$i]";
432 }
433 print "\n";
434 }
435 # print the whole thing sorted by number of members
437 foreach $family ( sort { @{$HoA{$b}} <=> @{$HoA{$a}} } keys %HoA ) {
438 print "$family: @{ $HoA{$family} }\n"
439 }
440 # print the whole thing sorted by number of members and name
442 foreach $family ( sort {
443 @{$HoA{$b}} <=> @{$HoA{$a}}
444 ||
445 $a cmp $b
446 } keys %HoA )
447 {
448 print "$family: ", join(", ", sort @{ $HoA{$family} }), "\n";
449 }
450
452 Declaration of an ARRAY OF HASHES
453 @AoH = (
454 {
455 Lead => "fred",
456 Friend => "barney",
457 },
458 {
459 Lead => "george",
460 Wife => "jane",
461 Son => "elroy",
462 },
463 {
464 Lead => "homer",
465 Wife => "marge",
466 Son => "bart",
467 }
468 );
469 Generation of an ARRAY OF HASHES
471 # reading from file
472 # format: LEAD=fred FRIEND=barney
473 while ( <> ) {
474 $rec = {};
475 for $field ( split ) {
476 ($key, $value) = split /=/, $field;
477 $rec->{$key} = $value;
478 }
479 push @AoH, $rec;
480 }
481 # reading from file
484 # format: LEAD=fred FRIEND=barney
485 # no temp
486 while ( <> ) {
487 push @AoH, { split /[\s+=]/ };
488 }
489 # calling a function that returns a key/value pair list, like
491 # "lead","fred","daughter","pebbles"
492 while ( %fields = getnextpairset() ) {
493 push @AoH, { %fields };
494 }
495 # likewise, but using no temp vars
497 while (<>) {
498 push @AoH, { parsepairs($_) };
499 }
500 # add key/value to an element
502 $AoH[0]{pet} = "dino";
503 $AoH[2]{pet} = "santa's little helper";
504 Access and Printing of an ARRAY OF HASHES
506 # one element
507 $AoH[0]{lead} = "fred";
508 # another element
510 $AoH[1]{lead} =~ s/(\w)/\u$1/;
511 # print the whole thing with refs
513 for $href ( @AoH ) {
514 print "{ ";
515 for $role ( keys %$href ) {
516 print "$role=$href->{$role} ";
517 }
518 print "}\n";
519 }
520 # print the whole thing with indices
522 for $i ( 0 .. $#AoH ) {
523 print "$i is { ";
524 for $role ( keys %{ $AoH[$i] } ) {
525 print "$role=$AoH[$i]{$role} ";
526 }
527 print "}\n";
528 }
529 # print the whole thing one at a time
531 for $i ( 0 .. $#AoH ) {
532 for $role ( keys %{ $AoH[$i] } ) {
533 print "elt $i $role is $AoH[$i]{$role}\n";
534 }
535 }
536
538 Declaration of a HASH OF HASHES
539 %HoH = (
540 flintstones => {
541 lead => "fred",
542 pal => "barney",
543 },
544 jetsons => {
545 lead => "george",
546 wife => "jane",
547 "his boy" => "elroy",
548 },
549 simpsons => {
550 lead => "homer",
551 wife => "marge",
552 kid => "bart",
553 },
554 );
555 Generation of a HASH OF HASHES
557 # reading from file
558 # flintstones: lead=fred pal=barney wife=wilma pet=dino
559 while ( <> ) {
560 next unless s/^(.*?):\s*//;
561 $who = $1;
562 for $field ( split ) {
563 ($key, $value) = split /=/, $field;
564 $HoH{$who}{$key} = $value;
565 }
566 # reading from file; more temps
569 while ( <> ) {
570 next unless s/^(.*?):\s*//;
571 $who = $1;
572 $rec = {};
573 $HoH{$who} = $rec;
574 for $field ( split ) {
575 ($key, $value) = split /=/, $field;
576 $rec->{$key} = $value;
577 }
578 }
579 # calling a function that returns a key,value hash
581 for $group ( "simpsons", "jetsons", "flintstones" ) {
582 $HoH{$group} = { get_family($group) };
583 }
584 # likewise, but using temps
586 for $group ( "simpsons", "jetsons", "flintstones" ) {
587 %members = get_family($group);
588 $HoH{$group} = { %members };
589 }
590 # append new members to an existing family
592 %new_folks = (
593 wife => "wilma",
594 pet => "dino",
595 );
596 for $what (keys %new_folks) {
598 $HoH{flintstones}{$what} = $new_folks{$what};
599 }
600 Access and Printing of a HASH OF HASHES
602 # one element
603 $HoH{flintstones}{wife} = "wilma";
604 # another element
606 $HoH{simpsons}{lead} =~ s/(\w)/\u$1/;
607 # print the whole thing
609 foreach $family ( keys %HoH ) {
610 print "$family: { ";
611 for $role ( keys %{ $HoH{$family} } ) {
612 print "$role=$HoH{$family}{$role} ";
613 }
614 print "}\n";
615 }
616 # print the whole thing somewhat sorted
618 foreach $family ( sort keys %HoH ) {
619 print "$family: { ";
620 for $role ( sort keys %{ $HoH{$family} } ) {
621 print "$role=$HoH{$family}{$role} ";
622 }
623 print "}\n";
624 }
625 # print the whole thing sorted by number of members
628 foreach $family ( sort { keys %{$HoH{$b}} <=> keys %{$HoH{$a}} } keys %HoH ) {
629 print "$family: { ";
630 for $role ( sort keys %{ $HoH{$family} } ) {
631 print "$role=$HoH{$family}{$role} ";
632 }
633 print "}\n";
634 }
635 # establish a sort order (rank) for each role
637 $i = 0;
638 for ( qw(lead wife son daughter pal pet) ) { $rank{$_} = ++$i }
639 # now print the whole thing sorted by number of members
641 foreach $family ( sort { keys %{ $HoH{$b} } <=> keys %{ $HoH{$a} } } keys %HoH ) {
642 print "$family: { ";
643 # and print these according to rank order
644 for $role ( sort { $rank{$a} <=> $rank{$b} } keys %{ $HoH{$family} } ) {
645 print "$role=$HoH{$family}{$role} ";
646 }
647 print "}\n";
648 }
649
651 Declaration of MORE ELABORATE RECORDS
652 Here's a sample showing how to create and use a record whose fields are
653 of many different sorts:
654 $rec = {
656 TEXT => $string,
657 SEQUENCE => [ @old_values ],
658 LOOKUP => { %some_table },
659 THATCODE => \&some_function,
660 THISCODE => sub { $_[0] ** $_[1] },
661 HANDLE => \*STDOUT,
662 };
663 print $rec->{TEXT};
665 print $rec->{SEQUENCE}[0];
667 $last = pop @ { $rec->{SEQUENCE} };
668 print $rec->{LOOKUP}{"key"};
670 ($first_k, $first_v) = each %{ $rec->{LOOKUP} };
671 $answer = $rec->{THATCODE}->($arg);
673 $answer = $rec->{THISCODE}->($arg1, $arg2);
674 # careful of extra block braces on fh ref
676 print { $rec->{HANDLE} } "a string\n";
677 use FileHandle;
679 $rec->{HANDLE}->autoflush(1);
680 $rec->{HANDLE}->print(" a string\n");
681 Declaration of a HASH OF COMPLEX RECORDS
683 %TV = (
684 flintstones => {
685 series => "flintstones",
686 nights => [ qw(monday thursday friday) ],
687 members => [
688 { name => "fred", role => "lead", age => 36, },
689 { name => "wilma", role => "wife", age => 31, },
690 { name => "pebbles", role => "kid", age => 4, },
691 ],
692 },
693 jetsons => {
695 series => "jetsons",
696 nights => [ qw(wednesday saturday) ],
697 members => [
698 { name => "george", role => "lead", age => 41, },
699 { name => "jane", role => "wife", age => 39, },
700 { name => "elroy", role => "kid", age => 9, },
701 ],
702 },
703 simpsons => {
705 series => "simpsons",
706 nights => [ qw(monday) ],
707 members => [
708 { name => "homer", role => "lead", age => 34, },
709 { name => "marge", role => "wife", age => 37, },
710 { name => "bart", role => "kid", age => 11, },
711 ],
712 },
713 );
714 Generation of a HASH OF COMPLEX RECORDS
716 # reading from file
717 # this is most easily done by having the file itself be
718 # in the raw data format as shown above. perl is happy
719 # to parse complex data structures if declared as data, so
720 # sometimes it's easiest to do that
721 # here's a piece by piece build up
723 $rec = {};
724 $rec->{series} = "flintstones";
725 $rec->{nights} = [ find_days() ];
726 @members = ();
728 # assume this file in field=value syntax
729 while (<>) {
730 %fields = split /[\s=]+/;
731 push @members, { %fields };
732 }
733 $rec->{members} = [ @members ];
734 # now remember the whole thing
736 $TV{ $rec->{series} } = $rec;
737 ###########################################################
739 # now, you might want to make interesting extra fields that
740 # include pointers back into the same data structure so if
741 # change one piece, it changes everywhere, like for example
742 # if you wanted a {kids} field that was a reference
743 # to an array of the kids' records without having duplicate
744 # records and thus update problems.
745 ###########################################################
746 foreach $family (keys %TV) {
747 $rec = $TV{$family}; # temp pointer
748 @kids = ();
749 for $person ( @{ $rec->{members} } ) {
750 if ($person->{role} =~ /kid|son|daughter/) {
751 push @kids, $person;
752 }
753 }
754 # REMEMBER: $rec and $TV{$family} point to same data!!
755 $rec->{kids} = [ @kids ];
756 }
757 # you copied the array, but the array itself contains pointers
759 # to uncopied objects. this means that if you make bart get
760 # older via
761 $TV{simpsons}{kids}[0]{age}++;
763 # then this would also change in
765 print $TV{simpsons}{members}[2]{age};
766 # because $TV{simpsons}{kids}[0] and $TV{simpsons}{members}[2]
768 # both point to the same underlying anonymous hash table
769 # print the whole thing
771 foreach $family ( keys %TV ) {
772 print "the $family";
773 print " is on during @{ $TV{$family}{nights} }\n";
774 print "its members are:\n";
775 for $who ( @{ $TV{$family}{members} } ) {
776 print " $who->{name} ($who->{role}), age $who->{age}\n";
777 }
778 print "it turns out that $TV{$family}{lead} has ";
779 print scalar ( @{ $TV{$family}{kids} } ), " kids named ";
780 print join (", ", map { $_->{name} } @{ $TV{$family}{kids} } );
781 print "\n";
782 }
783
785 You cannot easily tie a multilevel data structure (such as a hash of
786 hashes) to a dbm file. The first problem is that all but GDBM and
787 Berkeley DB have size limitations, but beyond that, you also have
788 problems with how references are to be represented on disk. One
789 experimental module that does partially attempt to address this need is
790 the MLDBM module. Check your nearest CPAN site as described in
791 perlmodlib for source code to MLDBM.
792
794 perlref(1), perllol(1), perldata(1), perlobj(1)
795
797 Tom Christiansen <tchrist@perl.com>
798 Last update: Wed Oct 23 04:57:50 MET DST 1996
800perl v5.10.1 2009-04-11 PERLDSC(1)