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

MAINTENANCE

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

KNOWN ISSUES

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

THANKS

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

TODO

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

SEE ALSO

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

SUPPORT

746       Bugs may be submitted at
747       <https://github.com/houseabsolute/List-SomeUtils/issues>.
748

SOURCE

750       The source code repository for List-SomeUtils can be found at
751       <https://github.com/houseabsolute/List-SomeUtils>.
752

DONATIONS

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

AUTHORS

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

CONTRIBUTORS

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