This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
Upgrade to Scalar-List-Utils 1.45 from CPAN
[perl5.git] / cpan / Scalar-List-Utils / lib / List / Util.pm
CommitLineData
2ff28616 1# Copyright (c) 1997-2009 Graham Barr <gbarr@pobox.com>. All rights reserved.
f4a2945e
JH
2# This program is free software; you can redistribute it and/or
3# modify it under the same terms as Perl itself.
2ff28616 4#
e99e4210 5# Maintained since 2013 by Paul Evans <leonerd@leonerd.org.uk>
f4a2945e
JH
6
7package List::Util;
8
82f35e8b 9use strict;
e8164ee7 10use warnings;
f4a2945e
JH
11require Exporter;
12
3630f57e 13our @ISA = qw(Exporter);
52102bb4 14our @EXPORT_OK = qw(
e8164ee7 15 all any first min max minstr maxstr none notall product reduce sum sum0 shuffle uniq uniqnum uniqstr
3d58dd24 16 pairs unpairs pairkeys pairvalues pairmap pairgrep pairfirst
52102bb4 17);
e8164ee7 18our $VERSION = "1.45";
3630f57e 19our $XS_VERSION = $VERSION;
60f3865b 20$VERSION = eval $VERSION;
f4a2945e 21
3630f57e
CBW
22require XSLoader;
23XSLoader::load('List::Util', $XS_VERSION);
09c2a9b8 24
52102bb4
SH
25sub import
26{
27 my $pkg = caller;
28
29 # (RT88848) Touch the caller's $a and $b, to avoid the warning of
30 # Name "main::a" used only once: possible typo" warning
31 no strict 'refs';
32 ${"${pkg}::a"} = ${"${pkg}::a"};
33 ${"${pkg}::b"} = ${"${pkg}::b"};
34
35 goto &Exporter::import;
36}
37
b823713c
CBW
38# For objects returned by pairs()
39sub List::Util::_Pair::key { shift->[0] }
40sub List::Util::_Pair::value { shift->[1] }
41
f4a2945e
JH
42=head1 NAME
43
44List::Util - A selection of general-utility list subroutines
45
46=head1 SYNOPSIS
47
e8164ee7
JH
48 use List::Util qw(
49 reduce any all none notall first
50
51 max maxstr min minstr product sum sum0
52
53 pairs pairkeys pairvalues pairfirst pairgrep pairmap
54
55 shuffle uniqnum uniqstr
56 );
f4a2945e
JH
57
58=head1 DESCRIPTION
59
8c167fd9
CBW
60C<List::Util> contains a selection of subroutines that people have expressed
61would be nice to have in the perl core, but the usage would not really be high
62enough to warrant the use of a keyword, and the size so small such that being
63individual extensions would be wasteful.
f4a2945e 64
6a9ebaf3 65By default C<List::Util> does not export any subroutines.
f4a2945e 66
6a9ebaf3
SH
67=cut
68
69=head1 LIST-REDUCTION FUNCTIONS
70
71The following set of functions all reduce a list down to a single value.
72
73=cut
74
e8164ee7
JH
75=head2 reduce
76
77 $result = reduce { BLOCK } @list
6a9ebaf3 78
8c167fd9
CBW
79Reduces C<@list> by calling C<BLOCK> in a scalar context multiple times,
80setting C<$a> and C<$b> each time. The first call will be with C<$a> and C<$b>
81set to the first two elements of the list, subsequent calls will be done by
82setting C<$a> to the result of the previous call and C<$b> to the next element
83in the list.
6a9ebaf3 84
8c167fd9
CBW
85Returns the result of the last call to the C<BLOCK>. If C<@list> is empty then
86C<undef> is returned. If C<@list> only contains one element then that element
87is returned and C<BLOCK> is not executed.
f4a2945e 88
8c167fd9
CBW
89The following examples all demonstrate how C<reduce> could be used to implement
90the other list-reduction functions in this module. (They are not in fact
91implemented like this, but instead in a more efficient manner in individual C
92functions).
e99e4210
SH
93
94 $foo = reduce { defined($a) ? $a :
95 $code->(local $_ = $b) ? $b :
96 undef } undef, @list # first
97
98 $foo = reduce { $a > $b ? $a : $b } 1..10 # max
99 $foo = reduce { $a gt $b ? $a : $b } 'A'..'Z' # maxstr
6a9ebaf3
SH
100 $foo = reduce { $a < $b ? $a : $b } 1..10 # min
101 $foo = reduce { $a lt $b ? $a : $b } 'aa'..'zz' # minstr
102 $foo = reduce { $a + $b } 1 .. 10 # sum
103 $foo = reduce { $a . $b } @bar # concat
104
e99e4210
SH
105 $foo = reduce { $a || $code->(local $_ = $b) } 0, @bar # any
106 $foo = reduce { $a && $code->(local $_ = $b) } 1, @bar # all
107 $foo = reduce { $a && !$code->(local $_ = $b) } 1, @bar # none
108 $foo = reduce { $a || !$code->(local $_ = $b) } 0, @bar # notall
109 # Note that these implementations do not fully short-circuit
110
8c167fd9
CBW
111If your algorithm requires that C<reduce> produce an identity value, then make
112sure that you always pass that identity value as the first argument to prevent
6a9ebaf3
SH
113C<undef> being returned
114
115 $foo = reduce { $a + $b } 0, @values; # sum with 0 identity value
116
e8164ee7
JH
117The above example code blocks also suggest how to use C<reduce> to build a
118more efficient combined version of one of these basic functions and a C<map>
119block. For example, to find the total length of the all the strings in a list,
120we could use
121
122 $total = sum map { length } @strings;
123
124However, this produces a list of temporary integer values as long as the
125original list of strings, only to reduce it down to a single value again. We
126can compute the same result more efficiently by using C<reduce> with a code
127block that accumulates lengths by writing this instead as:
128
129 $total = reduce { $a + length $b } 0, @strings
130
8c167fd9
CBW
131The remaining list-reduction functions are all specialisations of this generic
132idea.
6a9ebaf3 133
d81c2d6a
CBW
134=head2 any
135
136 my $bool = any { BLOCK } @list;
52102bb4 137
b823713c
CBW
138I<Since version 1.33.>
139
8c167fd9
CBW
140Similar to C<grep> in that it evaluates C<BLOCK> setting C<$_> to each element
141of C<@list> in turn. C<any> returns true if any element makes the C<BLOCK>
142return a true value. If C<BLOCK> never returns true or C<@list> was empty then
143it returns false.
52102bb4
SH
144
145Many cases of using C<grep> in a conditional can be written using C<any>
146instead, as it can short-circuit after the first true result.
147
148 if( any { length > 10 } @strings ) {
149 # at least one string has more than 10 characters
150 }
151
d81c2d6a
CBW
152=head2 all
153
154 my $bool = all { BLOCK } @list;
52102bb4 155
b823713c
CBW
156I<Since version 1.33.>
157
d81c2d6a
CBW
158Similar to L</any>, except that it requires all elements of the C<@list> to
159make the C<BLOCK> return true. If any element returns false, then it returns
160false. If the C<BLOCK> never returns false or the C<@list> was empty then it
161returns true.
162
163=head2 none
52102bb4 164
d81c2d6a 165=head2 notall
52102bb4 166
d81c2d6a
CBW
167 my $bool = none { BLOCK } @list;
168
169 my $bool = notall { BLOCK } @list;
52102bb4 170
b823713c
CBW
171I<Since version 1.33.>
172
d81c2d6a
CBW
173Similar to L</any> and L</all>, but with the return sense inverted. C<none>
174returns true only if no value in the C<@list> causes the C<BLOCK> to return
175true, and C<notall> returns true only if not all of the values do.
176
177=head2 first
52102bb4 178
d81c2d6a 179 my $val = first { BLOCK } @list;
f4a2945e 180
8c167fd9
CBW
181Similar to C<grep> in that it evaluates C<BLOCK> setting C<$_> to each element
182of C<@list> in turn. C<first> returns the first element where the result from
183C<BLOCK> is a true value. If C<BLOCK> never returns true or C<@list> was empty
184then C<undef> is returned.
f4a2945e
JH
185
186 $foo = first { defined($_) } @list # first defined value in @list
187 $foo = first { $_ > $value } @list # first value in @list which
188 # is greater than $value
c29e891d 189
d81c2d6a
CBW
190=head2 max
191
192 my $num = max @list;
f4a2945e 193
8c167fd9
CBW
194Returns the entry in the list with the highest numerical value. If the list is
195empty then C<undef> is returned.
f4a2945e
JH
196
197 $foo = max 1..10 # 10
198 $foo = max 3,9,12 # 12
199 $foo = max @bar, @baz # whatever
200
d81c2d6a
CBW
201=head2 maxstr
202
203 my $str = maxstr @list;
f4a2945e 204
d81c2d6a 205Similar to L</max>, but treats all the entries in the list as strings and
8c167fd9
CBW
206returns the highest string as defined by the C<gt> operator. If the list is
207empty then C<undef> is returned.
c29e891d
GB
208
209 $foo = maxstr 'A'..'Z' # 'Z'
f4a2945e
JH
210 $foo = maxstr "hello","world" # "world"
211 $foo = maxstr @bar, @baz # whatever
212
d81c2d6a
CBW
213=head2 min
214
215 my $num = min @list;
f4a2945e 216
d81c2d6a 217Similar to L</max> but returns the entry in the list with the lowest numerical
8c167fd9 218value. If the list is empty then C<undef> is returned.
f4a2945e
JH
219
220 $foo = min 1..10 # 1
221 $foo = min 3,9,12 # 3
222 $foo = min @bar, @baz # whatever
223
d81c2d6a 224=head2 minstr
f4a2945e 225
d81c2d6a
CBW
226 my $str = minstr @list;
227
228Similar to L</min>, but treats all the entries in the list as strings and
8c167fd9
CBW
229returns the lowest string as defined by the C<lt> operator. If the list is
230empty then C<undef> is returned.
f4a2945e 231
c29e891d
GB
232 $foo = minstr 'A'..'Z' # 'A'
233 $foo = minstr "hello","world" # "hello"
234 $foo = minstr @bar, @baz # whatever
f4a2945e 235
d81c2d6a
CBW
236=head2 product
237
238 my $num = product @list;
98eca5fa 239
b823713c
CBW
240I<Since version 1.35.>
241
8c167fd9
CBW
242Returns the numerical product of all the elements in C<@list>. If C<@list> is
243empty then C<1> is returned.
98eca5fa
SH
244
245 $foo = product 1..10 # 3628800
246 $foo = product 3,9,12 # 324
247
d81c2d6a
CBW
248=head2 sum
249
250 my $num_or_undef = sum @list;
6a9ebaf3 251
8c167fd9
CBW
252Returns the numerical sum of all the elements in C<@list>. For backwards
253compatibility, if C<@list> is empty then C<undef> is returned.
6a9ebaf3
SH
254
255 $foo = sum 1..10 # 55
256 $foo = sum 3,9,12 # 24
257 $foo = sum @bar, @baz # whatever
258
d81c2d6a
CBW
259=head2 sum0
260
261 my $num = sum0 @list;
6a9ebaf3 262
b823713c
CBW
263I<Since version 1.26.>
264
d81c2d6a
CBW
265Similar to L</sum>, except this returns 0 when given an empty list, rather
266than C<undef>.
6a9ebaf3
SH
267
268=cut
269
270=head1 KEY/VALUE PAIR LIST FUNCTIONS
271
8c167fd9
CBW
272The following set of functions, all inspired by L<List::Pairwise>, consume an
273even-sized list of pairs. The pairs may be key/value associations from a hash,
274or just a list of values. The functions will all preserve the original ordering
275of the pairs, and will not be confused by multiple pairs having the same "key"
276value - nor even do they require that the first of each pair be a plain string.
6a9ebaf3 277
3d58dd24
SH
278B<NOTE>: At the time of writing, the following C<pair*> functions that take a
279block do not modify the value of C<$_> within the block, and instead operate
280using the C<$a> and C<$b> globals instead. This has turned out to be a poor
281design, as it precludes the ability to provide a C<pairsort> function. Better
282would be to pass pair-like objects as 2-element array references in C<$_>, in
283a style similar to the return value of the C<pairs> function. At some future
284version this behaviour may be added.
285
286Until then, users are alerted B<NOT> to rely on the value of C<$_> remaining
287unmodified between the outside and the inside of the control block. In
288particular, the following example is B<UNSAFE>:
289
290 my @kvlist = ...
291
292 foreach (qw( some keys here )) {
293 my @items = pairgrep { $a eq $_ } @kvlist;
294 ...
295 }
296
297Instead, write this using a lexical variable:
298
299 foreach my $key (qw( some keys here )) {
300 my @items = pairgrep { $a eq $key } @kvlist;
301 ...
302 }
303
6a9ebaf3
SH
304=cut
305
3d58dd24
SH
306=head2 pairs
307
308 my @pairs = pairs @kvlist;
309
310I<Since version 1.29.>
311
312A convenient shortcut to operating on even-sized lists of pairs, this function
e8164ee7
JH
313returns a list of C<ARRAY> references, each containing two items from the
314given list. It is a more efficient version of
3d58dd24
SH
315
316 @pairs = pairmap { [ $a, $b ] } @kvlist
317
318It is most convenient to use in a C<foreach> loop, for example:
319
e8164ee7 320 foreach my $pair ( pairs @kvlist ) {
3d58dd24
SH
321 my ( $key, $value ) = @$pair;
322 ...
323 }
324
e8164ee7
JH
325Since version C<1.39> these C<ARRAY> references are blessed objects,
326recognising the two methods C<key> and C<value>. The following code is
327equivalent:
3d58dd24 328
e8164ee7 329 foreach my $pair ( pairs @kvlist ) {
3d58dd24
SH
330 my $key = $pair->key;
331 my $value = $pair->value;
332 ...
333 }
334
335=head2 unpairs
336
337 my @kvlist = unpairs @pairs
338
339I<Since version 1.42.>
340
e8164ee7 341The inverse function to C<pairs>; this function takes a list of C<ARRAY>
3d58dd24
SH
342references containing two elements each, and returns a flattened list of the
343two values from each of the pairs, in order. This is notionally equivalent to
344
345 my @kvlist = map { @{$_}[0,1] } @pairs
346
347except that it is implemented more efficiently internally. Specifically, for
348any input item it will extract exactly two values for the output list; using
349C<undef> if the input array references are short.
350
351Between C<pairs> and C<unpairs>, a higher-order list function can be used to
352operate on the pairs as single scalars; such as the following near-equivalents
353of the other C<pair*> higher-order functions:
354
355 @kvlist = unpairs grep { FUNC } pairs @kvlist
356 # Like pairgrep, but takes $_ instead of $a and $b
357
358 @kvlist = unpairs map { FUNC } pairs @kvlist
359 # Like pairmap, but takes $_ instead of $a and $b
360
361Note however that these versions will not behave as nicely in scalar context.
362
363Finally, this technique can be used to implement a sort on a keyvalue pair
364list; e.g.:
365
366 @kvlist = unpairs sort { $a->key cmp $b->key } pairs @kvlist
367
368=head2 pairkeys
369
370 my @keys = pairkeys @kvlist;
371
372I<Since version 1.29.>
373
374A convenient shortcut to operating on even-sized lists of pairs, this function
375returns a list of the the first values of each of the pairs in the given list.
376It is a more efficient version of
377
378 @keys = pairmap { $a } @kvlist
379
380=head2 pairvalues
381
382 my @values = pairvalues @kvlist;
383
384I<Since version 1.29.>
385
386A convenient shortcut to operating on even-sized lists of pairs, this function
387returns a list of the the second values of each of the pairs in the given list.
388It is a more efficient version of
389
390 @values = pairmap { $b } @kvlist
391
d81c2d6a
CBW
392=head2 pairgrep
393
394 my @kvlist = pairgrep { BLOCK } @kvlist;
8c167fd9 395
d81c2d6a 396 my $count = pairgrep { BLOCK } @kvlist;
2dc8d725 397
b823713c
CBW
398I<Since version 1.29.>
399
2dc8d725 400Similar to perl's C<grep> keyword, but interprets the given list as an
8c167fd9 401even-sized list of pairs. It invokes the C<BLOCK> multiple times, in scalar
2dc8d725 402context, with C<$a> and C<$b> set to successive pairs of values from the
8c167fd9 403C<@kvlist>.
2dc8d725 404
8c167fd9 405Returns an even-sized list of those pairs for which the C<BLOCK> returned true
2dc8d725 406in list context, or the count of the B<number of pairs> in scalar context.
8c167fd9
CBW
407(Note, therefore, in scalar context that it returns a number half the size of
408the count of items it would have returned in list context).
2dc8d725
CBW
409
410 @subset = pairgrep { $a =~ m/^[[:upper:]]+$/ } @kvlist
411
8c167fd9
CBW
412As with C<grep> aliasing C<$_> to list elements, C<pairgrep> aliases C<$a> and
413C<$b> to elements of the given list. Any modifications of it by the code block
414will be visible to the caller.
2dc8d725 415
d81c2d6a 416=head2 pairfirst
8c167fd9 417
d81c2d6a
CBW
418 my ( $key, $val ) = pairfirst { BLOCK } @kvlist;
419
420 my $found = pairfirst { BLOCK } @kvlist;
6a9ebaf3 421
b823713c
CBW
422I<Since version 1.30.>
423
d81c2d6a 424Similar to the L</first> function, but interprets the given list as an
8c167fd9 425even-sized list of pairs. It invokes the C<BLOCK> multiple times, in scalar
6a9ebaf3 426context, with C<$a> and C<$b> set to successive pairs of values from the
8c167fd9 427C<@kvlist>.
6a9ebaf3 428
8c167fd9 429Returns the first pair of values from the list for which the C<BLOCK> returned
6a9ebaf3
SH
430true in list context, or an empty list of no such pair was found. In scalar
431context it returns a simple boolean value, rather than either the key or the
432value found.
433
434 ( $key, $value ) = pairfirst { $a =~ m/^[[:upper:]]+$/ } @kvlist
435
8c167fd9
CBW
436As with C<grep> aliasing C<$_> to list elements, C<pairfirst> aliases C<$a> and
437C<$b> to elements of the given list. Any modifications of it by the code block
438will be visible to the caller.
439
d81c2d6a
CBW
440=head2 pairmap
441
442 my @list = pairmap { BLOCK } @kvlist;
6a9ebaf3 443
d81c2d6a 444 my $count = pairmap { BLOCK } @kvlist;
2dc8d725 445
b823713c
CBW
446I<Since version 1.29.>
447
2dc8d725 448Similar to perl's C<map> keyword, but interprets the given list as an
8c167fd9 449even-sized list of pairs. It invokes the C<BLOCK> multiple times, in list
2dc8d725 450context, with C<$a> and C<$b> set to successive pairs of values from the
8c167fd9 451C<@kvlist>.
2dc8d725 452
8c167fd9
CBW
453Returns the concatenation of all the values returned by the C<BLOCK> in list
454context, or the count of the number of items that would have been returned in
455scalar context.
2dc8d725
CBW
456
457 @result = pairmap { "The key $a has value $b" } @kvlist
458
8c167fd9
CBW
459As with C<map> aliasing C<$_> to list elements, C<pairmap> aliases C<$a> and
460C<$b> to elements of the given list. Any modifications of it by the code block
461will be visible to the caller.
2dc8d725 462
b823713c
CBW
463See L</KNOWN BUGS> for a known-bug with C<pairmap>, and a workaround.
464
6a9ebaf3 465=cut
f4a2945e 466
6a9ebaf3 467=head1 OTHER FUNCTIONS
f4a2945e 468
6a9ebaf3 469=cut
2ff28616 470
d81c2d6a
CBW
471=head2 shuffle
472
473 my @values = shuffle @values;
1bfb5477 474
8c167fd9 475Returns the values of the input in a random order
1bfb5477 476
c29e891d
GB
477 @cards = shuffle 0..51 # 0..51 in a random order
478
e8164ee7
JH
479=head2 uniq
480
481 my @subset = uniq @values
482
483I<Since version 1.45.>
484
485Filters a list of values to remove subsequent duplicates, as judged by a
486DWIM-ish string equality or C<undef> test. Preserves the order of unique
487elements, and retains the first value of any duplicate set.
488
489 my $count = uniq @values
490
491In scalar context, returns the number of elements that would have been
492returned as a list.
493
494The C<undef> value is treated by this function as distinct from the empty
495string, and no warning will be produced. It is left as-is in the returned
496list. Subsequent C<undef> values are still considered identical to the first,
497and will be removed.
498
499=head2 uniqnum
500
501 my @subset = uniqnum @values
502
503I<Since version 1.44.>
504
505Filters a list of values to remove subsequent duplicates, as judged by a
506numerical equality test. Preserves the order of unique elements, and retains
507the first value of any duplicate set.
508
509 my $count = uniqnum @values
510
511In scalar context, returns the number of elements that would have been
512returned as a list.
513
514Note that C<undef> is treated much as other numerical operations treat it; it
515compares equal to zero but additionally produces a warning if such warnings
516are enabled (C<use warnings 'uninitialized';>). In addition, an C<undef> in
517the returned list is coerced into a numerical zero, so that the entire list of
518values returned by C<uniqnum> are well-behaved as numbers.
519
520=head2 uniqstr
521
522 my @subset = uniqstr @values
523
524I<Since version 1.45.>
525
526Filters a list of values to remove subsequent duplicates, as judged by a
527string equality test. Preserves the order of unique elements, and retains the
528first value of any duplicate set.
529
530 my $count = uniqstr @values
531
532In scalar context, returns the number of elements that would have been
533returned as a list.
534
535Note that C<undef> is treated much as other string operations treat it; it
536compares equal to the empty string but additionally produces a warning if such
537warnings are enabled (C<use warnings 'uninitialized';>). In addition, an
538C<undef> in the returned list is coerced into an empty string, so that the
539entire list of values returned by C<uniqstr> are well-behaved as strings.
540
6a9ebaf3 541=cut
f4a2945e 542
9c3c560b
JH
543=head1 KNOWN BUGS
544
b823713c
CBW
545=head2 RT #95409
546
547L<https://rt.cpan.org/Ticket/Display.html?id=95409>
548
d81c2d6a 549If the block of code given to L</pairmap> contains lexical variables that are
b823713c
CBW
550captured by a returned closure, and the closure is executed after the block
551has been re-used for the next iteration, these lexicals will not see the
552correct values. For example:
553
554 my @subs = pairmap {
555 my $var = "$a is $b";
556 sub { print "$var\n" };
557 } one => 1, two => 2, three => 3;
558
559 $_->() for @subs;
560
561Will incorrectly print
562
563 three is 3
564 three is 3
565 three is 3
566
567This is due to the performance optimisation of using C<MULTICALL> for the code
568block, which means that fresh SVs do not get allocated for each call to the
569block. Instead, the same SV is re-assigned for each iteration, and all the
570closures will share the value seen on the final iteration.
571
572To work around this bug, surround the code with a second set of braces. This
573creates an inner block that defeats the C<MULTICALL> logic, and does get fresh
574SVs allocated each time:
575
576 my @subs = pairmap {
577 {
578 my $var = "$a is $b";
579 sub { print "$var\n"; }
580 }
581 } one => 1, two => 2, three => 3;
582
583This bug only affects closures that are generated by the block but used
584afterwards. Lexical variables that are only used during the lifetime of the
585block's execution will take their individual values for each invocation, as
586normal.
9c3c560b 587
e8164ee7
JH
588=head2 uniqnum() on oversized bignums
589
590Due to the way that C<uniqnum()> compares numbers, it cannot distinguish
591differences between bignums (especially bigints) that are too large to fit in
592the native platform types. For example,
593
594 my $x = Math::BigInt->new( "1" x 100 );
595 my $y = $x + 1;
596
597 say for uniqnum( $x, $y );
598
599Will print just the value of C<$x>, believing that C<$y> is a numerically-
600equivalent value. This bug does not affect C<uniqstr()>, which will correctly
601observe that the two values stringify to different strings.
602
f4a2945e
JH
603=head1 SUGGESTED ADDITIONS
604
605The following are additions that have been requested, but I have been reluctant
606to add due to them being very simple to implement in perl
607
f4a2945e
JH
608 # How many elements are true
609
610 sub true { scalar grep { $_ } @_ }
611
612 # How many elements are false
613
614 sub false { scalar grep { !$_ } @_ }
615
ddf53ba4
GB
616=head1 SEE ALSO
617
618L<Scalar::Util>, L<List::MoreUtils>
619
f4a2945e
JH
620=head1 COPYRIGHT
621
2ff28616 622Copyright (c) 1997-2007 Graham Barr <gbarr@pobox.com>. All rights reserved.
f4a2945e
JH
623This program is free software; you can redistribute it and/or
624modify it under the same terms as Perl itself.
625
6a9ebaf3
SH
626Recent additions and current maintenance by
627Paul Evans, <leonerd@leonerd.org.uk>.
628
f4a2945e 629=cut
e8164ee7
JH
630
6311;