1List::SomeUtils(3)    User Contributed Perl Documentation   List::SomeUtils(3)
2
3
4

NAME

6       List::SomeUtils - Provide the stuff missing in List::Util
7

VERSION

9       version 0.56
10

SYNOPSIS

12           # import specific functions
13           use List::SomeUtils qw( any uniq );
14
15           if ( any {/foo/} uniq @has_duplicates ) {
16
17               # do stuff
18           }
19
20           # import everything
21           use List::SomeUtils ':all';
22

DESCRIPTION

24       List::SomeUtils provides some trivial but commonly needed functionality
25       on lists which is not going to go into List::Util.
26
27       All of the below functions are implementable in only a couple of lines
28       of Perl code. Using the functions from this module however should give
29       slightly better performance as everything is implemented in C. The
30       pure-Perl implementation of these functions only serves as a fallback
31       in case the C portions of this module couldn't be compiled on this
32       machine.
33

WHY DOES THIS MODULE EXIST?

35       You might wonder why this module exists when we already have
36       List::MoreUtils. In fact, this module is (nearly) the same code as is
37       found in LMU with no significant changes. However, the LMU distribution
38       depends on several modules for configuration (to run the Makefile.PL)
39       that some folks in the Perl community don't think are appropriate for a
40       module high upstream in the CPAN river.
41
42       I (Dave Rolsky) don't have a strong opinion on this, but I do like the
43       functions provided by LMU, and I'm tired of getting patches and PRs to
44       remove LMU from my code.
45
46       This distribution exists to let me use the functionality I like without
47       having to get into tiring arguments about issues I don't really care
48       about.
49

EXPORTS

51   Default behavior
52       Nothing by default. To import all of this module's symbols use the
53       ":all" tag.  Otherwise functions can be imported by name as usual:
54
55           use List::SomeUtils ':all';
56
57           use List::SomeUtils qw{ any firstidx };
58
59       Because historical changes to the API might make upgrading
60       List::SomeUtils difficult for some projects, the legacy API is
61       available via special import tags.
62

FUNCTIONS

64   Junctions
65       Treatment of an empty list
66
67       There are two schools of thought for how to evaluate a junction on an
68       empty list:
69
70       ·   Reduction to an identity (boolean)
71
72       ·   Result is undefined (three-valued)
73
74       In the first case, the result of the junction applied to the empty list
75       is determined by a mathematical reduction to an identity depending on
76       whether the underlying comparison is "or" or "and".  Conceptually:
77
78                           "any are true"      "all are true"
79                           --------------      --------------
80           2 elements:     A || B || 0         A && B && 1
81           1 element:      A || 0              A && 1
82           0 elements:     0                   1
83
84       In the second case, three-value logic is desired, in which a junction
85       applied to an empty list returns "undef" rather than true or false
86
87       Junctions with a "_u" suffix implement three-valued logic.  Those
88       without are boolean.
89
90       all BLOCK LIST
91
92       all_u BLOCK LIST
93
94       Returns a true value if all items in LIST meet the criterion given
95       through BLOCK. Sets $_ for each item in LIST in turn:
96
97         print "All values are non-negative"
98           if all { $_ >= 0 } ($x, $y, $z);
99
100       For an empty LIST, "all" returns true (i.e. no values failed the
101       condition) and "all_u" returns "undef".
102
103       Thus, "all_u(@list)" is equivalent to "@list ? all(@list) : undef".
104
105       Note: because Perl treats "undef" as false, you must check the return
106       value of "all_u" with "defined" or you will get the opposite result of
107       what you expect.
108
109       any BLOCK LIST
110
111       any_u BLOCK LIST
112
113       Returns a true value if any item in LIST meets the criterion given
114       through BLOCK. Sets $_ for each item in LIST in turn:
115
116         print "At least one non-negative value"
117           if any { $_ >= 0 } ($x, $y, $z);
118
119       For an empty LIST, "any" returns false and "any_u" returns "undef".
120
121       Thus, "any_u(@list)" is equivalent to "@list ? any(@list) : undef".
122
123       none BLOCK LIST
124
125       none_u BLOCK LIST
126
127       Logically the negation of "any". Returns a true value if no item in
128       LIST meets the criterion given through BLOCK. Sets $_ for each item in
129       LIST in turn:
130
131         print "No non-negative values"
132           if none { $_ >= 0 } ($x, $y, $z);
133
134       For an empty LIST, "none" returns true (i.e. no values failed the
135       condition) and "none_u" returns "undef".
136
137       Thus, "none_u(@list)" is equivalent to "@list ? none(@list) : undef".
138
139       Note: because Perl treats "undef" as false, you must check the return
140       value of "none_u" with "defined" or you will get the opposite result of
141       what you expect.
142
143       notall BLOCK LIST
144
145       notall_u BLOCK LIST
146
147       Logically the negation of "all". Returns a true value if not all items
148       in LIST meet the criterion given through BLOCK. Sets $_ for each item
149       in LIST in turn:
150
151         print "Not all values are non-negative"
152           if notall { $_ >= 0 } ($x, $y, $z);
153
154       For an empty LIST, "notall" returns false and "notall_u" returns
155       "undef".
156
157       Thus, "notall_u(@list)" is equivalent to "@list ? notall(@list) :
158       undef".
159
160       one BLOCK LIST
161
162       one_u BLOCK LIST
163
164       Returns a true value if precisely one item in LIST meets the criterion
165       given through BLOCK. Sets $_ for each item in LIST in turn:
166
167           print "Precisely one value defined"
168               if one { defined($_) } @list;
169
170       Returns false otherwise.
171
172       For an empty LIST, "one" returns false and "one_u" returns "undef".
173
174       The expression "one BLOCK LIST" is almost equivalent to "1 == true
175       BLOCK LIST", except for short-cutting.  Evaluation of BLOCK will
176       immediately stop at the second true value.
177
178   Transformation
179       apply BLOCK LIST
180
181       Applies BLOCK to each item in LIST and returns a list of the values
182       after BLOCK has been applied. In scalar context, the last element is
183       returned.  This function is similar to "map" but will not modify the
184       elements of the input list:
185
186         my @list = (1 .. 4);
187         my @mult = apply { $_ *= 2 } @list;
188         print "\@list = @list\n";
189         print "\@mult = @mult\n";
190         __END__
191         @list = 1 2 3 4
192         @mult = 2 4 6 8
193
194       Think of it as syntactic sugar for
195
196         for (my @mult = @list) { $_ *= 2 }
197
198       insert_after BLOCK VALUE LIST
199
200       Inserts VALUE after the first item in LIST for which the criterion in
201       BLOCK is true. Sets $_ for each item in LIST in turn.
202
203         my @list = qw/This is a list/;
204         insert_after { $_ eq "a" } "longer" => @list;
205         print "@list";
206         __END__
207         This is a longer list
208
209       insert_after_string STRING VALUE LIST
210
211       Inserts VALUE after the first item in LIST which is equal to STRING.
212
213         my @list = qw/This is a list/;
214         insert_after_string "a", "longer" => @list;
215         print "@list";
216         __END__
217         This is a longer list
218
219       pairwise BLOCK ARRAY1 ARRAY2
220
221       Evaluates BLOCK for each pair of elements in ARRAY1 and ARRAY2 and
222       returns a new list consisting of BLOCK's return values. The two
223       elements are set to $a and $b.  Note that those two are aliases to the
224       original value so changing them will modify the input arrays.
225
226         @a = (1 .. 5);
227         @b = (11 .. 15);
228         @x = pairwise { $a + $b } @a, @b;     # returns 12, 14, 16, 18, 20
229
230         # mesh with pairwise
231         @a = qw/a b c/;
232         @b = qw/1 2 3/;
233         @x = pairwise { ($a, $b) } @a, @b;    # returns a, 1, b, 2, c, 3
234
235       mesh ARRAY1 ARRAY2 [ ARRAY3 ... ]
236
237       zip ARRAY1 ARRAY2 [ ARRAY3 ... ]
238
239       Returns a list consisting of the first elements of each array, then the
240       second, then the third, etc, until all arrays are exhausted.
241
242       Examples:
243
244         @x = qw/a b c d/;
245         @y = qw/1 2 3 4/;
246         @z = mesh @x, @y;         # returns a, 1, b, 2, c, 3, d, 4
247
248         @a = ('x');
249         @b = ('1', '2');
250         @c = qw/zip zap zot/;
251         @d = mesh @a, @b, @c;   # x, 1, zip, undef, 2, zap, undef, undef, zot
252
253       "zip" is an alias for "mesh".
254
255       uniq LIST
256
257       distinct LIST
258
259       Returns a new list by stripping duplicate values in LIST by comparing
260       the values as hash keys, except that undef is considered separate from
261       ''.  The order of elements in the returned list is the same as in LIST.
262       In scalar context, returns the number of unique elements in LIST.
263
264         my @x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 1 2 3 5 4
265         my $x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 5
266         # returns "Mike", "Michael", "Richard", "Rick"
267         my @n = distinct "Mike", "Michael", "Richard", "Rick", "Michael", "Rick"
268         # returns '', undef, 'S1', A5'
269         my @s = distinct '', undef, 'S1', 'A5'
270         # returns '', undef, 'S1', A5'
271         my @w = uniq undef, '', 'S1', 'A5'
272
273       "distinct" is an alias for "uniq".
274
275       RT#49800 can be used to give feedback about this behavior.
276
277       singleton
278
279       Returns a new list by stripping values in LIST occurring more than once
280       by comparing the values as hash keys, except that undef is considered
281       separate from ''.  The order of elements in the returned list is the
282       same as in LIST.  In scalar context, returns the number of elements
283       occurring only once in LIST.
284
285         my @x = singleton 1,1,2,2,3,4,5 # returns 3 4 5
286
287   Partitioning
288       after BLOCK LIST
289
290       Returns a list of the values of LIST after (and not including) the
291       point where BLOCK returns a true value. Sets $_ for each element in
292       LIST in turn.
293
294         @x = after { $_ % 5 == 0 } (1..9);    # returns 6, 7, 8, 9
295
296       after_incl BLOCK LIST
297
298       Same as "after" but also includes the element for which BLOCK is true.
299
300       before BLOCK LIST
301
302       Returns a list of values of LIST up to (and not including) the point
303       where BLOCK returns a true value. Sets $_ for each element in LIST in
304       turn.
305
306       before_incl BLOCK LIST
307
308       Same as "before" but also includes the element for which BLOCK is true.
309
310       part BLOCK LIST
311
312       Partitions LIST based on the return value of BLOCK which denotes into
313       which partition the current value is put.
314
315       Returns a list of the partitions thusly created. Each partition created
316       is a reference to an array.
317
318         my $i = 0;
319         my @part = part { $i++ % 2 } 1 .. 8;   # returns [1, 3, 5, 7], [2, 4, 6, 8]
320
321       You can have a sparse list of partitions as well where non-set
322       partitions will be undef:
323
324         my @part = part { 2 } 1 .. 10;            # returns undef, undef, [ 1 .. 10 ]
325
326       Be careful with negative values, though:
327
328         my @part = part { -1 } 1 .. 10;
329         __END__
330         Modification of non-creatable array value attempted, subscript -1 ...
331
332       Negative values are only ok when they refer to a partition previously
333       created:
334
335         my @idx  = ( 0, 1, -1 );
336         my $i    = 0;
337         my @part = part { $idx[$++ % 3] } 1 .. 8; # [1, 4, 7], [2, 3, 5, 6, 8]
338
339   Iteration
340       each_array ARRAY1 ARRAY2 ...
341
342       Creates an array iterator to return the elements of the list of arrays
343       ARRAY1, ARRAY2 throughout ARRAYn in turn.  That is, the first time it
344       is called, it returns the first element of each array.  The next time,
345       it returns the second elements.  And so on, until all elements are
346       exhausted.
347
348       This is useful for looping over more than one array at once:
349
350         my $ea = each_array(@a, @b, @c);
351         while ( my ($a, $b, $c) = $ea->() )   { .... }
352
353       The iterator returns the empty list when it reached the end of all
354       arrays.
355
356       If the iterator is passed an argument of '"index"', then it returns the
357       index of the last fetched set of values, as a scalar.
358
359       each_arrayref LIST
360
361       Like each_array, but the arguments are references to arrays, not the
362       plain arrays.
363
364       natatime EXPR, LIST
365
366       Creates an array iterator, for looping over an array in chunks of $n
367       items at a time.  (n at a time, get it?).  An example is probably a
368       better explanation than I could give in words.
369
370       Example:
371
372         my @x = ('a' .. 'g');
373         my $it = natatime 3, @x;
374         while (my @vals = $it->())
375         {
376           print "@vals\n";
377         }
378
379       This prints
380
381         a b c
382         d e f
383         g
384
385   Searching
386       bsearch BLOCK LIST
387
388       Performs a binary search on LIST which must be a sorted list of values.
389       BLOCK must return a negative value if the current element (stored in
390       $_) is smaller, a positive value if it is bigger and zero if it
391       matches.
392
393       Returns a boolean value in scalar context. In list context, it returns
394       the element if it was found, otherwise the empty list.
395
396       bsearchidx BLOCK LIST
397
398       bsearch_index BLOCK LIST
399
400       Performs a binary search on LIST which must be a sorted list of values.
401       BLOCK must return a negative value if the current element (stored in
402       $_) is smaller, a positive value if it is bigger and zero if it
403       matches.
404
405       Returns the index of found element, otherwise "-1".
406
407       "bsearch_index" is an alias for "bsearchidx".
408
409       firstval BLOCK LIST
410
411       first_value BLOCK LIST
412
413       Returns the first element in LIST for which BLOCK evaluates to true.
414       Each element of LIST is set to $_ in turn. Returns "undef" if no such
415       element has been found.
416
417       "first_value" is an alias for "firstval".
418
419       onlyval BLOCK LIST
420
421       only_value BLOCK LIST
422
423       Returns the only element in LIST for which BLOCK evaluates to true.
424       Sets $_ for each item in LIST in turn. Returns "undef" if no such
425       element has been found.
426
427       "only_value" is an alias for "onlyval".
428
429       lastval BLOCK LIST
430
431       last_value BLOCK LIST
432
433       Returns the last value in LIST for which BLOCK evaluates to true. Each
434       element of LIST is set to $_ in turn. Returns "undef" if no such
435       element has been found.
436
437       "last_value" is an alias for "lastval".
438
439       firstres BLOCK LIST
440
441       first_result BLOCK LIST
442
443       Returns the result of BLOCK for the first element in LIST for which
444       BLOCK evaluates to true. Each element of LIST is set to $_ in turn.
445       Returns "undef" if no such element has been found.
446
447       "first_result" is an alias for "firstres".
448
449       onlyres BLOCK LIST
450
451       only_result BLOCK LIST
452
453       Returns the result of BLOCK for the first element in LIST for which
454       BLOCK evaluates to true. Sets $_ for each item in LIST in turn. Returns
455       "undef" if no such element has been found.
456
457       "only_result" is an alias for "onlyres".
458
459       lastres BLOCK LIST
460
461       last_result BLOCK LIST
462
463       Returns the result of BLOCK for the last element in LIST for which
464       BLOCK evaluates to true. Each element of LIST is set to $_ in turn.
465       Returns "undef" if no such element has been found.
466
467       "last_result" is an alias for "lastres".
468
469       indexes BLOCK LIST
470
471       Evaluates BLOCK for each element in LIST (assigned to $_) and returns a
472       list of the indices of those elements for which BLOCK returned a true
473       value. This is just like "grep" only that it returns indices instead of
474       values:
475
476         @x = indexes { $_ % 2 == 0 } (1..10);   # returns 1, 3, 5, 7, 9
477
478       firstidx BLOCK LIST
479
480       first_index BLOCK LIST
481
482       Returns the index of the first element in LIST for which the criterion
483       in BLOCK is true. Sets $_ for each item in LIST in turn:
484
485         my @list = (1, 4, 3, 2, 4, 6);
486         printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
487         __END__
488         item with index 1 in list is 4
489
490       Returns "-1" if no such item could be found.
491
492       "first_index" is an alias for "firstidx".
493
494       onlyidx BLOCK LIST
495
496       only_index BLOCK LIST
497
498       Returns the index of the only element in LIST for which the criterion
499       in BLOCK is true. Sets $_ for each item in LIST in turn:
500
501           my @list = (1, 3, 4, 3, 2, 4);
502           printf "uniqe index of item 2 in list is %i", onlyidx { $_ == 2 } @list;
503           __END__
504           unique index of item 2 in list is 4
505
506       Returns "-1" if either no such item or more than one of these has been
507       found.
508
509       "only_index" is an alias for "onlyidx".
510
511       lastidx BLOCK LIST
512
513       last_index BLOCK LIST
514
515       Returns the index of the last element in LIST for which the criterion
516       in BLOCK is true. Sets $_ for each item in LIST in turn:
517
518         my @list = (1, 4, 3, 2, 4, 6);
519         printf "item with index %i in list is 4", lastidx { $_ == 4 } @list;
520         __END__
521         item with index 4 in list is 4
522
523       Returns "-1" if no such item could be found.
524
525       "last_index" is an alias for "lastidx".
526
527   Sorting
528       sort_by BLOCK LIST
529
530       Returns the list of values sorted according to the string values
531       returned by the KEYFUNC block or function. A typical use of this may be
532       to sort objects according to the string value of some accessor, such as
533
534         sort_by { $_->name } @people
535
536       The key function is called in scalar context, being passed each value
537       in turn as both $_ and the only argument in the parameters, @_. The
538       values are then sorted according to string comparisons on the values
539       returned.  This is equivalent to
540
541         sort { $a->name cmp $b->name } @people
542
543       except that it guarantees the name accessor will be executed only once
544       per value.  One interesting use-case is to sort strings which may have
545       numbers embedded in them "naturally", rather than lexically.
546
547         sort_by { s/(\d+)/sprintf "%09d", $1/eg; $_ } @strings
548
549       This sorts strings by generating sort keys which zero-pad the embedded
550       numbers to some level (9 digits in this case), helping to ensure the
551       lexical sort puts them in the correct order.
552
553       nsort_by BLOCK LIST
554
555       Similar to sort_by but compares its key values numerically.
556
557   Counting and calculation
558       true BLOCK LIST
559
560       Counts the number of elements in LIST for which the criterion in BLOCK
561       is true.  Sets $_ for  each item in LIST in turn:
562
563         printf "%i item(s) are defined", true { defined($_) } @list;
564
565       false BLOCK LIST
566
567       Counts the number of elements in LIST for which the criterion in BLOCK
568       is false.  Sets $_ for each item in LIST in turn:
569
570         printf "%i item(s) are not defined", false { defined($_) } @list;
571
572       minmax LIST
573
574       Calculates the minimum and maximum of LIST and returns a two element
575       list with the first element being the minimum and the second the
576       maximum. Returns the empty list if LIST was empty.
577
578       The "minmax" algorithm differs from a naive iteration over the list
579       where each element is compared to two values being the so far
580       calculated min and max value in that it only requires 3n/2 - 2
581       comparisons. Thus it is the most efficient possible algorithm.
582
583       However, the Perl implementation of it has some overhead simply due to
584       the fact that there are more lines of Perl code involved. Therefore,
585       LIST needs to be fairly big in order for "minmax" to win over a naive
586       implementation. This limitation does not apply to the XS version.
587
588       mode LIST
589
590       Calculates the most common items in the list and returns them as a
591       list. This is effectively done by string comparisons, so references
592       will be stringified. If they implement string overloading, this will be
593       used.
594
595       If more than one item appears the same number of times in the list, all
596       such items will be returned. For example, the mode of a unique list is
597       the list itself.
598
599       This function always returns a list. That means that in scalar context
600       you get a count indicating the number of modes in the list.
601

MAINTENANCE

603       The maintenance goal is to preserve the documented semantics of the
604       API; bug fixes that bring actual behavior in line with semantics are
605       allowed.  New API functions may be added over time.  If a backwards
606       incompatible change is unavoidable, we will attempt to provide support
607       for the legacy API using the same export tag mechanism currently in
608       place.
609
610       This module attempts to use few non-core dependencies. Non-core
611       configuration and testing modules will be bundled when reasonable; run-
612       time dependencies will be added only if they deliver substantial
613       benefit.
614

KNOWN ISSUES

616       There is a problem with a bug in 5.6.x perls. It is a syntax error to
617       write things like:
618
619           my @x = apply { s/foo/bar/ } qw{ foo bar baz };
620
621       It has to be written as either
622
623           my @x = apply { s/foo/bar/ } 'foo', 'bar', 'baz';
624
625       or
626
627           my @x = apply { s/foo/bar/ } my @dummy = qw/foo bar baz/;
628
629       Perl 5.5.x and Perl 5.8.x don't suffer from this limitation.
630
631       If you have a functionality that you could imagine being in this
632       module, please drop me a line. This module's policy will be less strict
633       than List::Util's when it comes to additions as it isn't a core module.
634
635       When you report bugs, it would be nice if you could additionally give
636       me the output of your program with the environment variable
637       "LIST_MOREUTILS_PP" set to a true value. That way I know where to look
638       for the problem (in XS, pure-Perl or possibly both).
639

THANKS

641   Tassilo von Parseval
642       Credits go to a number of people: Steve Purkis for giving me namespace
643       advice and James Keenan and Terrence Branno for their effort of keeping
644       the CPAN tidier by making List::Util obsolete.
645
646       Brian McCauley suggested the inclusion of apply() and provided the
647       pure-Perl implementation for it.
648
649       Eric J. Roode asked me to add all functions from his module
650       "List::SomeUtil" into this one. With minor modifications, the pure-Perl
651       implementations of those are by him.
652
653       The bunch of people who almost immediately pointed out the many
654       problems with the glitchy 0.07 release (Slaven Rezic, Ron Savage, CPAN
655       testers).
656
657       A particularly nasty memory leak was spotted by Thomas A. Lowery.
658
659       Lars Thegler made me aware of problems with older Perl versions.
660
661       Anno Siegel de-orphaned each_arrayref().
662
663       David Filmer made me aware of a problem in each_arrayref that could
664       ultimately lead to a segfault.
665
666       Ricardo Signes suggested the inclusion of part() and provided the Perl-
667       implementation.
668
669       Robin Huston kindly fixed a bug in perl's MULTICALL API to make the XS-
670       implementation of part() work.
671
672   Jens Rehsack
673       Credits goes to all people contributing feedback during the v0.400
674       development releases.
675
676       Special thanks goes to David Golden who spent a lot of effort to
677       develop a design to support current state of CPAN as well as ancient
678       software somewhere in the dark. He also contributed a lot of patches to
679       refactor the API frontend to welcome any user of List::SomeUtils - from
680       ancient past to recently last used.
681
682       Toby Inkster provided a lot of useful feedback for sane importer code
683       and was a nice sounding board for API discussions.
684
685       Peter Rabbitson provided a sane git repository setup containing entire
686       package history.
687

TODO

689       A pile of requests from other people is still pending further
690       processing in my mailbox. This includes:
691
692       ·   List::Util export pass-through
693
694           Allow List::SomeUtils to pass-through the regular List::Util
695           functions to end users only need to "use" the one module.
696
697       ·   uniq_by(&@)
698
699           Use code-reference to extract a key based on which the uniqueness
700           is determined. Suggested by Aaron Crane.
701
702       ·   delete_index
703
704       ·   random_item
705
706       ·   random_item_delete_index
707
708       ·   list_diff_hash
709
710       ·   list_diff_inboth
711
712       ·   list_diff_infirst
713
714       ·   list_diff_insecond
715
716           These were all suggested by Dan Muey.
717
718       ·   listify
719
720           Always return a flat list when either a simple scalar value was
721           passed or an array-reference. Suggested by Mark Summersault.
722

SEE ALSO

724       List::Util, List::AllUtils, List::UtilsBy
725
727       Some parts copyright 2011 Aaron Crane.
728
729       Copyright 2004 - 2010 by Tassilo von Parseval
730
731       Copyright 2013 - 2015 by Jens Rehsack
732

SUPPORT

734       Bugs may be submitted at
735       <https://github.com/houseabsolute/List-SomeUtils/issues>.
736
737       I am also usually active on IRC as 'autarch' on "irc://irc.perl.org".
738

SOURCE

740       The source code repository for List-SomeUtils can be found at
741       <https://github.com/houseabsolute/List-SomeUtils>.
742

DONATIONS

744       If you'd like to thank me for the work I've done on this module, please
745       consider making a "donation" to me via PayPal. I spend a lot of free
746       time creating free software, and would appreciate any support you'd
747       care to offer.
748
749       Please note that I am not suggesting that you must do this in order for
750       me to continue working on this particular software. I will continue to
751       do so, inasmuch as I have in the past, for as long as it interests me.
752
753       Similarly, a donation made in this way will probably not make me work
754       on this software much more, unless I get so many donations that I can
755       consider working on free software full time (let's all have a chuckle
756       at that together).
757
758       To donate, log into PayPal and send money to autarch@urth.org, or use
759       the button at <http://www.urth.org/~autarch/fs-donation.html>.
760

AUTHORS

762       ·   Tassilo von Parseval <tassilo.von.parseval@rwth-aachen.de>
763
764       ·   Adam Kennedy <adamk@cpan.org>
765
766       ·   Jens Rehsack <rehsack@cpan.org>
767
768       ·   Dave Rolsky <autarch@urth.org>
769

CONTRIBUTORS

771       ·   Aaron Crane <arc@cpan.org>
772
773       ·   BackPan <BackPan>
774
775       ·   Brad Forschinger <bnjf@bnjf.id.au>
776
777       ·   David Golden <dagolden@cpan.org>
778
779       ·   jddurand <jeandamiendurand@free.fr>
780
781       ·   Jens Rehsack <sno@netbsd.org>
782
783       ·   J.R. Mash <jrmash@cpan.org>
784
785       ·   Karen Etheridge <ether@cpan.org>
786
787       ·   Ricardo Signes <rjbs@cpan.org>
788
789       ·   Toby Inkster <mail@tobyinkster.co.uk>
790
791       ·   Tokuhiro Matsuno <tokuhirom@cpan.org>
792
793       ·   Tom Wyant <wyant@cpan.org>
794
796       This software is copyright (c) 2017 by Dave Rolsky <autarch@urth.org>.
797
798       This is free software; you can redistribute it and/or modify it under
799       the same terms as the Perl 5 programming language system itself.
800
801       The full text of the license can be found in the LICENSE file included
802       with this distribution.
803
804
805
806perl v5.28.0                      2017-07-22                List::SomeUtils(3)
Impressum