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.58
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       Makes a copy of the list and then passes each element from the copy to
182       the BLOCK. Any changes or assignments to $_ in the BLOCK will only
183       affect the elements of the new list. However, if $_ is a reference then
184       changes to the referenced value will be seen in both the original and
185       new list.
186
187       This function is similar to "map" but will not modify the elements of
188       the input list:
189
190         my @list = (1 .. 4);
191         my @mult = apply { $_ *= 2 } @list;
192         print "\@list = @list\n";
193         print "\@mult = @mult\n";
194         __END__
195         @list = 1 2 3 4
196         @mult = 2 4 6 8
197
198       Think of it as syntactic sugar for
199
200         for (my @mult = @list) { $_ *= 2 }
201
202       Note that you must alter $_ directly inside BLOCK in order for changes
203       to make effect. New value returned from the BLOCK are ignored:
204
205         # @new is identical to @list.
206         my @new = apply { $_ * 2 } @list;
207
208         # @new is different from @list
209         my @new = apply { $_ =* 2 } @list;
210
211       insert_after BLOCK VALUE LIST
212
213       Inserts VALUE after the first item in LIST for which the criterion in
214       BLOCK is true. Sets $_ for each item in LIST in turn.
215
216         my @list = qw/This is a list/;
217         insert_after { $_ eq "a" } "longer" => @list;
218         print "@list";
219         __END__
220         This is a longer list
221
222       insert_after_string STRING VALUE LIST
223
224       Inserts VALUE after the first item in LIST which is equal to STRING.
225
226         my @list = qw/This is a list/;
227         insert_after_string "a", "longer" => @list;
228         print "@list";
229         __END__
230         This is a longer list
231
232       pairwise BLOCK ARRAY1 ARRAY2
233
234       Evaluates BLOCK for each pair of elements in ARRAY1 and ARRAY2 and
235       returns a new list consisting of BLOCK's return values. The two
236       elements are set to $a and $b.  Note that those two are aliases to the
237       original value so changing them will modify the input arrays.
238
239         @a = (1 .. 5);
240         @b = (11 .. 15);
241         @x = pairwise { $a + $b } @a, @b;     # returns 12, 14, 16, 18, 20
242
243         # mesh with pairwise
244         @a = qw/a b c/;
245         @b = qw/1 2 3/;
246         @x = pairwise { ($a, $b) } @a, @b;    # returns a, 1, b, 2, c, 3
247
248       mesh ARRAY1 ARRAY2 [ ARRAY3 ... ]
249
250       zip ARRAY1 ARRAY2 [ ARRAY3 ... ]
251
252       Returns a list consisting of the first elements of each array, then the
253       second, then the third, etc, until all arrays are exhausted.
254
255       Examples:
256
257         @x = qw/a b c d/;
258         @y = qw/1 2 3 4/;
259         @z = mesh @x, @y;         # returns a, 1, b, 2, c, 3, d, 4
260
261         @a = ('x');
262         @b = ('1', '2');
263         @c = qw/zip zap zot/;
264         @d = mesh @a, @b, @c;   # x, 1, zip, undef, 2, zap, undef, undef, zot
265
266       "zip" is an alias for "mesh".
267
268       uniq LIST
269
270       distinct LIST
271
272       Returns a new list by stripping duplicate values in LIST by comparing
273       the values as hash keys, except that undef is considered separate from
274       ''.  The order of elements in the returned list is the same as in LIST.
275       In scalar context, returns the number of unique elements in LIST.
276
277         my @x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 1 2 3 5 4
278         my $x = uniq 1, 1, 2, 2, 3, 5, 3, 4; # returns 5
279         # returns "Mike", "Michael", "Richard", "Rick"
280         my @n = distinct "Mike", "Michael", "Richard", "Rick", "Michael", "Rick"
281         # returns '', undef, 'S1', A5'
282         my @s = distinct '', undef, 'S1', 'A5'
283         # returns '', undef, 'S1', A5'
284         my @w = uniq undef, '', 'S1', 'A5'
285
286       "distinct" is an alias for "uniq".
287
288       RT#49800 can be used to give feedback about this behavior.
289
290       singleton
291
292       Returns a new list by stripping values in LIST occurring more than once
293       by comparing the values as hash keys, except that undef is considered
294       separate from ''.  The order of elements in the returned list is the
295       same as in LIST.  In scalar context, returns the number of elements
296       occurring only once in LIST.
297
298         my @x = singleton 1,1,2,2,3,4,5 # returns 3 4 5
299
300   Partitioning
301       after BLOCK LIST
302
303       Returns a list of the values of LIST after (and not including) the
304       point where BLOCK returns a true value. Sets $_ for each element in
305       LIST in turn.
306
307         @x = after { $_ % 5 == 0 } (1..9);    # returns 6, 7, 8, 9
308
309       after_incl BLOCK LIST
310
311       Same as "after" but also includes the element for which BLOCK is true.
312
313       before BLOCK LIST
314
315       Returns a list of values of LIST up to (and not including) the point
316       where BLOCK returns a true value. Sets $_ for each element in LIST in
317       turn.
318
319       before_incl BLOCK LIST
320
321       Same as "before" but also includes the element for which BLOCK is true.
322
323       part BLOCK LIST
324
325       Partitions LIST based on the return value of BLOCK which denotes into
326       which partition the current value is put.
327
328       Returns a list of the partitions thusly created. Each partition created
329       is a reference to an array.
330
331         my $i = 0;
332         my @part = part { $i++ % 2 } 1 .. 8;   # returns [1, 3, 5, 7], [2, 4, 6, 8]
333
334       You can have a sparse list of partitions as well where non-set
335       partitions will be undef:
336
337         my @part = part { 2 } 1 .. 10;            # returns undef, undef, [ 1 .. 10 ]
338
339       Be careful with negative values, though:
340
341         my @part = part { -1 } 1 .. 10;
342         __END__
343         Modification of non-creatable array value attempted, subscript -1 ...
344
345       Negative values are only ok when they refer to a partition previously
346       created:
347
348         my @idx  = ( 0, 1, -1 );
349         my $i    = 0;
350         my @part = part { $idx[$i++ % 3] } 1 .. 8; # [1, 4, 7], [2, 3, 5, 6, 8]
351
352   Iteration
353       each_array ARRAY1 ARRAY2 ...
354
355       Creates an array iterator to return the elements of the list of arrays
356       ARRAY1, ARRAY2 throughout ARRAYn in turn.  That is, the first time it
357       is called, it returns the first element of each array.  The next time,
358       it returns the second elements.  And so on, until all elements are
359       exhausted.
360
361       This is useful for looping over more than one array at once:
362
363         my $ea = each_array(@a, @b, @c);
364         while ( my ($a, $b, $c) = $ea->() )   { .... }
365
366       The iterator returns the empty list when it reached the end of all
367       arrays.
368
369       If the iterator is passed an argument of '"index"', then it returns the
370       index of the last fetched set of values, as a scalar.
371
372       each_arrayref LIST
373
374       Like each_array, but the arguments are references to arrays, not the
375       plain arrays.
376
377       natatime EXPR, LIST
378
379       Creates an array iterator, for looping over an array in chunks of $n
380       items at a time.  (n at a time, get it?).  An example is probably a
381       better explanation than I could give in words.
382
383       Example:
384
385         my @x = ('a' .. 'g');
386         my $it = natatime 3, @x;
387         while (my @vals = $it->())
388         {
389           print "@vals\n";
390         }
391
392       This prints
393
394         a b c
395         d e f
396         g
397
398   Searching
399       bsearch BLOCK LIST
400
401       Performs a binary search on LIST which must be a sorted list of values.
402       BLOCK must return a negative value if the current element (stored in
403       $_) is smaller, a positive value if it is bigger and zero if it
404       matches.
405
406       Returns a boolean value in scalar context. In list context, it returns
407       the element if it was found, otherwise the empty list.
408
409       bsearchidx BLOCK LIST
410
411       bsearch_index BLOCK LIST
412
413       Performs a binary search on LIST which must be a sorted list of values.
414       BLOCK must return a negative value if the current element (stored in
415       $_) is smaller, a positive value if it is bigger and zero if it
416       matches.
417
418       Returns the index of found element, otherwise "-1".
419
420       "bsearch_index" is an alias for "bsearchidx".
421
422       firstval BLOCK LIST
423
424       first_value BLOCK LIST
425
426       Returns the first element in LIST for which BLOCK evaluates to true.
427       Each element of LIST is set to $_ in turn. Returns "undef" if no such
428       element has been found.
429
430       "first_value" is an alias for "firstval".
431
432       onlyval BLOCK LIST
433
434       only_value BLOCK LIST
435
436       Returns the only element in LIST for which BLOCK evaluates to true.
437       Sets $_ for each item in LIST in turn. Returns "undef" if no such
438       element has been found.
439
440       "only_value" is an alias for "onlyval".
441
442       lastval BLOCK LIST
443
444       last_value BLOCK LIST
445
446       Returns the last value in LIST for which BLOCK evaluates to true. Each
447       element of LIST is set to $_ in turn. Returns "undef" if no such
448       element has been found.
449
450       "last_value" is an alias for "lastval".
451
452       firstres BLOCK LIST
453
454       first_result BLOCK LIST
455
456       Returns the result of BLOCK for the first element in LIST for which
457       BLOCK evaluates to true. Each element of LIST is set to $_ in turn.
458       Returns "undef" if no such element has been found.
459
460       "first_result" is an alias for "firstres".
461
462       onlyres BLOCK LIST
463
464       only_result BLOCK LIST
465
466       Returns the result of BLOCK for the first element in LIST for which
467       BLOCK evaluates to true. Sets $_ for each item in LIST in turn. Returns
468       "undef" if no such element has been found.
469
470       "only_result" is an alias for "onlyres".
471
472       lastres BLOCK LIST
473
474       last_result BLOCK LIST
475
476       Returns the result of BLOCK for the last element in LIST for which
477       BLOCK evaluates to true. Each element of LIST is set to $_ in turn.
478       Returns "undef" if no such element has been found.
479
480       "last_result" is an alias for "lastres".
481
482       indexes BLOCK LIST
483
484       Evaluates BLOCK for each element in LIST (assigned to $_) and returns a
485       list of the indices of those elements for which BLOCK returned a true
486       value. This is just like "grep" only that it returns indices instead of
487       values:
488
489         @x = indexes { $_ % 2 == 0 } (1..10);   # returns 1, 3, 5, 7, 9
490
491       firstidx BLOCK LIST
492
493       first_index BLOCK LIST
494
495       Returns the index of the first element in LIST for which the criterion
496       in BLOCK is true. Sets $_ for each item in LIST in turn:
497
498         my @list = (1, 4, 3, 2, 4, 6);
499         printf "item with index %i in list is 4", firstidx { $_ == 4 } @list;
500         __END__
501         item with index 1 in list is 4
502
503       Returns "-1" if no such item could be found.
504
505       "first_index" is an alias for "firstidx".
506
507       onlyidx BLOCK LIST
508
509       only_index BLOCK LIST
510
511       Returns the index of the only element in LIST for which the criterion
512       in BLOCK is true. Sets $_ for each item in LIST in turn:
513
514           my @list = (1, 3, 4, 3, 2, 4);
515           printf "uniqe index of item 2 in list is %i", onlyidx { $_ == 2 } @list;
516           __END__
517           unique index of item 2 in list is 4
518
519       Returns "-1" if either no such item or more than one of these has been
520       found.
521
522       "only_index" is an alias for "onlyidx".
523
524       lastidx BLOCK LIST
525
526       last_index BLOCK LIST
527
528       Returns the index of the last element in LIST for which the criterion
529       in BLOCK is true. Sets $_ for each item in LIST in turn:
530
531         my @list = (1, 4, 3, 2, 4, 6);
532         printf "item with index %i in list is 4", lastidx { $_ == 4 } @list;
533         __END__
534         item with index 4 in list is 4
535
536       Returns "-1" if no such item could be found.
537
538       "last_index" is an alias for "lastidx".
539
540   Sorting
541       sort_by BLOCK LIST
542
543       Returns the list of values sorted according to the string values
544       returned by the KEYFUNC block or function. A typical use of this may be
545       to sort objects according to the string value of some accessor, such as
546
547         sort_by { $_->name } @people
548
549       The key function is called in scalar context, being passed each value
550       in turn as both $_ and the only argument in the parameters, @_. The
551       values are then sorted according to string comparisons on the values
552       returned.  This is equivalent to
553
554         sort { $a->name cmp $b->name } @people
555
556       except that it guarantees the name accessor will be executed only once
557       per value.  One interesting use-case is to sort strings which may have
558       numbers embedded in them "naturally", rather than lexically.
559
560         sort_by { s/(\d+)/sprintf "%09d", $1/eg; $_ } @strings
561
562       This sorts strings by generating sort keys which zero-pad the embedded
563       numbers to some level (9 digits in this case), helping to ensure the
564       lexical sort puts them in the correct order.
565
566       nsort_by BLOCK LIST
567
568       Similar to sort_by but compares its key values numerically.
569
570   Counting and calculation
571       true BLOCK LIST
572
573       Counts the number of elements in LIST for which the criterion in BLOCK
574       is true.  Sets $_ for  each item in LIST in turn:
575
576         printf "%i item(s) are defined", true { defined($_) } @list;
577
578       false BLOCK LIST
579
580       Counts the number of elements in LIST for which the criterion in BLOCK
581       is false.  Sets $_ for each item in LIST in turn:
582
583         printf "%i item(s) are not defined", false { defined($_) } @list;
584
585       minmax LIST
586
587       Calculates the minimum and maximum of LIST and returns a two element
588       list with the first element being the minimum and the second the
589       maximum. Returns the empty list if LIST was empty.
590
591       The "minmax" algorithm differs from a naive iteration over the list
592       where each element is compared to two values being the so far
593       calculated min and max value in that it only requires 3n/2 - 2
594       comparisons. Thus it is the most efficient possible algorithm.
595
596       However, the Perl implementation of it has some overhead simply due to
597       the fact that there are more lines of Perl code involved. Therefore,
598       LIST needs to be fairly big in order for "minmax" to win over a naive
599       implementation. This limitation does not apply to the XS version.
600
601       mode LIST
602
603       Calculates the most common items in the list and returns them as a
604       list. This is effectively done by string comparisons, so references
605       will be stringified. If they implement string overloading, this will be
606       used.
607
608       If more than one item appears the same number of times in the list, all
609       such items will be returned. For example, the mode of a unique list is
610       the list itself.
611
612       This function returns a list in list context. In scalar context it
613       returns a count indicating the number of modes in the list.
614

MAINTENANCE

616       The maintenance goal is to preserve the documented semantics of the
617       API; bug fixes that bring actual behavior in line with semantics are
618       allowed.  New API functions may be added over time.  If a backwards
619       incompatible change is unavoidable, we will attempt to provide support
620       for the legacy API using the same export tag mechanism currently in
621       place.
622
623       This module attempts to use few non-core dependencies. Non-core
624       configuration and testing modules will be bundled when reasonable; run-
625       time dependencies will be added only if they deliver substantial
626       benefit.
627

KNOWN ISSUES

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

THANKS

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

TODO

702       A pile of requests from other people is still pending further
703       processing in my mailbox. This includes:
704
705       •   List::Util export pass-through
706
707           Allow List::SomeUtils to pass-through the regular List::Util
708           functions to end users only need to "use" the one module.
709
710       •   uniq_by(&@)
711
712           Use code-reference to extract a key based on which the uniqueness
713           is determined. Suggested by Aaron Crane.
714
715       •   delete_index
716
717       •   random_item
718
719       •   random_item_delete_index
720
721       •   list_diff_hash
722
723       •   list_diff_inboth
724
725       •   list_diff_infirst
726
727       •   list_diff_insecond
728
729           These were all suggested by Dan Muey.
730
731       •   listify
732
733           Always return a flat list when either a simple scalar value was
734           passed or an array-reference. Suggested by Mark Summersault.
735

SEE ALSO

737       List::Util, List::AllUtils, List::UtilsBy
738
740       Some parts copyright 2011 Aaron Crane.
741
742       Copyright 2004 - 2010 by Tassilo von Parseval
743
744       Copyright 2013 - 2015 by Jens Rehsack
745

SUPPORT

747       Bugs may be submitted at
748       <https://github.com/houseabsolute/List-SomeUtils/issues>.
749
750       I am also usually active on IRC as 'autarch' on "irc://irc.perl.org".
751

SOURCE

753       The source code repository for List-SomeUtils can be found at
754       <https://github.com/houseabsolute/List-SomeUtils>.
755

DONATIONS

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

AUTHORS

775       •   Tassilo von Parseval <tassilo.von.parseval@rwth-aachen.de>
776
777       •   Adam Kennedy <adamk@cpan.org>
778
779       •   Jens Rehsack <rehsack@cpan.org>
780
781       •   Dave Rolsky <autarch@urth.org>
782

CONTRIBUTORS

784       •   Aaron Crane <arc@cpan.org>
785
786       •   BackPan <BackPan>
787
788       •   bay-max1 <34803732+bay-max1@users.noreply.github.com>
789
790       •   Brad Forschinger <bnjf@bnjf.id.au>
791
792       •   David Golden <dagolden@cpan.org>
793
794       •   jddurand <jeandamiendurand@free.fr>
795
796       •   Jens Rehsack <sno@netbsd.org>
797
798       •   J.R. Mash <jrmash@cpan.org>
799
800       •   Karen Etheridge <ether@cpan.org>
801
802       •   Ricardo Signes <rjbs@cpan.org>
803
804       •   Toby Inkster <mail@tobyinkster.co.uk>
805
806       •   Tokuhiro Matsuno <tokuhirom@cpan.org>
807
808       •   Tom Wyant <wyant@cpan.org>
809
811       This software is copyright (c) 2019 by Dave Rolsky <autarch@urth.org>.
812
813       This is free software; you can redistribute it and/or modify it under
814       the same terms as the Perl 5 programming language system itself.
815
816       The full text of the license can be found in the LICENSE file included
817       with this distribution.
818
819
820
821perl v5.34.0                      2022-01-21                List::SomeUtils(3)
Impressum