1List::SomeUtils(3) User Contributed Perl Documentation List::SomeUtils(3)
2
6 List::SomeUtils - Provide the stuff missing in List::Util
7
9 version 0.58
10
12 # import specific functions
13 use List::SomeUtils qw( any uniq );
14 if ( any {/foo/} uniq @has_duplicates ) {
16 # do stuff
18 }
19 # import everything
21 use List::SomeUtils ':all';
22
24 List::SomeUtils provides some trivial but commonly needed functionality
25 on lists which is not going to go into List::Util.
26 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
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 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 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
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 use List::SomeUtils ':all';
56 use List::SomeUtils qw{ any firstidx };
58 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
64 Junctions
65 Treatment of an empty list
66 There are two schools of thought for how to evaluate a junction on an
68 empty list:
69 · Reduction to an identity (boolean)
71 · Result is undefined (three-valued)
73 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 "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 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 Junctions with a "_u" suffix implement three-valued logic. Those
88 without are boolean.
89 all BLOCK LIST
91 all_u BLOCK LIST
93 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 print "All values are non-negative"
98 if all { $_ >= 0 } ($x, $y, $z);
99 For an empty LIST, "all" returns true (i.e. no values failed the
101 condition) and "all_u" returns "undef".
102 Thus, "all_u(@list)" is equivalent to "@list ? all(@list) : undef".
104 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 any BLOCK LIST
110 any_u BLOCK LIST
112 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 print "At least one non-negative value"
117 if any { $_ >= 0 } ($x, $y, $z);
118 For an empty LIST, "any" returns false and "any_u" returns "undef".
120 Thus, "any_u(@list)" is equivalent to "@list ? any(@list) : undef".
122 none BLOCK LIST
124 none_u BLOCK LIST
126 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 print "No non-negative values"
132 if none { $_ >= 0 } ($x, $y, $z);
133 For an empty LIST, "none" returns true (i.e. no values failed the
135 condition) and "none_u" returns "undef".
136 Thus, "none_u(@list)" is equivalent to "@list ? none(@list) : undef".
138 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 notall BLOCK LIST
144 notall_u BLOCK LIST
146 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 print "Not all values are non-negative"
152 if notall { $_ >= 0 } ($x, $y, $z);
153 For an empty LIST, "notall" returns false and "notall_u" returns
155 "undef".
156 Thus, "notall_u(@list)" is equivalent to "@list ? notall(@list) :
158 undef".
159 one BLOCK LIST
161 one_u BLOCK LIST
163 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 print "Precisely one value defined"
168 if one { defined($_) } @list;
169 Returns false otherwise.
171 For an empty LIST, "one" returns false and "one_u" returns "undef".
173 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 Transformation
179 apply BLOCK LIST
180 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 This function is similar to "map" but will not modify the elements of
188 the input list:
189 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 Think of it as syntactic sugar for
199 for (my @mult = @list) { $_ *= 2 }
201 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 # @new is identical to @list.
206 my @new = apply { $_ * 2 } @list;
207 # @new is different from @list
209 my @new = apply { $_ =* 2 } @list;
210 insert_after BLOCK VALUE LIST
212 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 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 insert_after_string STRING VALUE LIST
223 Inserts VALUE after the first item in LIST which is equal to STRING.
225 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 pairwise BLOCK ARRAY1 ARRAY2
233 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 @a = (1 .. 5);
240 @b = (11 .. 15);
241 @x = pairwise { $a + $b } @a, @b; # returns 12, 14, 16, 18, 20
242 # 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 mesh ARRAY1 ARRAY2 [ ARRAY3 ... ]
249 zip ARRAY1 ARRAY2 [ ARRAY3 ... ]
251 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 Examples:
256 @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 @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 "zip" is an alias for "mesh".
267 uniq LIST
269 distinct LIST
271 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 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 "distinct" is an alias for "uniq".
287 RT#49800 can be used to give feedback about this behavior.
289 singleton
291 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 my @x = singleton 1,1,2,2,3,4,5 # returns 3 4 5
299 Partitioning
301 after BLOCK LIST
302 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 @x = after { $_ % 5 == 0 } (1..9); # returns 6, 7, 8, 9
308 after_incl BLOCK LIST
310 Same as "after" but also includes the element for which BLOCK is true.
312 before BLOCK LIST
314 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 before_incl BLOCK LIST
320 Same as "before" but also includes the element for which BLOCK is true.
322 part BLOCK LIST
324 Partitions LIST based on the return value of BLOCK which denotes into
326 which partition the current value is put.
327 Returns a list of the partitions thusly created. Each partition created
329 is a reference to an array.
330 my $i = 0;
332 my @part = part { $i++ % 2 } 1 .. 8; # returns [1, 3, 5, 7], [2, 4, 6, 8]
333 You can have a sparse list of partitions as well where non-set
335 partitions will be undef:
336 my @part = part { 2 } 1 .. 10; # returns undef, undef, [ 1 .. 10 ]
338 Be careful with negative values, though:
340 my @part = part { -1 } 1 .. 10;
342 __END__
343 Modification of non-creatable array value attempted, subscript -1 ...
344 Negative values are only ok when they refer to a partition previously
346 created:
347 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 Iteration
353 each_array ARRAY1 ARRAY2 ...
354 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 This is useful for looping over more than one array at once:
362 my $ea = each_array(@a, @b, @c);
364 while ( my ($a, $b, $c) = $ea->() ) { .... }
365 The iterator returns the empty list when it reached the end of all
367 arrays.
368 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 each_arrayref LIST
373 Like each_array, but the arguments are references to arrays, not the
375 plain arrays.
376 natatime EXPR, LIST
378 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 Example:
384 my @x = ('a' .. 'g');
386 my $it = natatime 3, @x;
387 while (my @vals = $it->())
388 {
389 print "@vals\n";
390 }
391 This prints
393 a b c
395 d e f
396 g
397 Searching
399 bsearch BLOCK LIST
400 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 Returns a boolean value in scalar context. In list context, it returns
407 the element if it was found, otherwise the empty list.
408 bsearchidx BLOCK LIST
410 bsearch_index BLOCK LIST
412 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 Returns the index of found element, otherwise "-1".
419 "bsearch_index" is an alias for "bsearchidx".
421 firstval BLOCK LIST
423 first_value BLOCK LIST
425 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 "first_value" is an alias for "firstval".
431 onlyval BLOCK LIST
433 only_value BLOCK LIST
435 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 "only_value" is an alias for "onlyval".
441 lastval BLOCK LIST
443 last_value BLOCK LIST
445 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 "last_value" is an alias for "lastval".
451 firstres BLOCK LIST
453 first_result BLOCK LIST
455 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 "first_result" is an alias for "firstres".
461 onlyres BLOCK LIST
463 only_result BLOCK LIST
465 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 "only_result" is an alias for "onlyres".
471 lastres BLOCK LIST
473 last_result BLOCK LIST
475 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 "last_result" is an alias for "lastres".
481 indexes BLOCK LIST
483 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 @x = indexes { $_ % 2 == 0 } (1..10); # returns 1, 3, 5, 7, 9
490 firstidx BLOCK LIST
492 first_index BLOCK LIST
494 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 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 Returns "-1" if no such item could be found.
504 "first_index" is an alias for "firstidx".
506 onlyidx BLOCK LIST
508 only_index BLOCK LIST
510 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 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 Returns "-1" if either no such item or more than one of these has been
520 found.
521 "only_index" is an alias for "onlyidx".
523 lastidx BLOCK LIST
525 last_index BLOCK LIST
527 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 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 Returns "-1" if no such item could be found.
537 "last_index" is an alias for "lastidx".
539 Sorting
541 sort_by BLOCK LIST
542 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 sort_by { $_->name } @people
548 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 sort { $a->name cmp $b->name } @people
555 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 sort_by { s/(\d+)/sprintf "%09d", $1/eg; $_ } @strings
561 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 nsort_by BLOCK LIST
567 Similar to sort_by but compares its key values numerically.
569 Counting and calculation
571 true BLOCK LIST
572 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 printf "%i item(s) are defined", true { defined($_) } @list;
577 false BLOCK LIST
579 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 printf "%i item(s) are not defined", false { defined($_) } @list;
584 minmax LIST
586 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 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 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 mode LIST
602 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 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 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
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 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
629 There is a problem with a bug in 5.6.x perls. It is a syntax error to
630 write things like:
631 my @x = apply { s/foo/bar/ } qw{ foo bar baz };
633 It has to be written as either
635 my @x = apply { s/foo/bar/ } 'foo', 'bar', 'baz';
637 or
639 my @x = apply { s/foo/bar/ } my @dummy = qw/foo bar baz/;
641 Perl 5.5.x and Perl 5.8.x don't suffer from this limitation.
643 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 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
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 Brian McCauley suggested the inclusion of apply() and provided the
660 pure-Perl implementation for it.
661 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 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 A particularly nasty memory leak was spotted by Thomas A. Lowery.
671 Lars Thegler made me aware of problems with older Perl versions.
673 Anno Siegel de-orphaned each_arrayref().
675 David Filmer made me aware of a problem in each_arrayref that could
677 ultimately lead to a segfault.
678 Ricardo Signes suggested the inclusion of part() and provided the Perl-
680 implementation.
681 Robin Huston kindly fixed a bug in perl's MULTICALL API to make the XS-
683 implementation of part() work.
684 Jens Rehsack
686 Credits goes to all people contributing feedback during the v0.400
687 development releases.
688 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 Toby Inkster provided a lot of useful feedback for sane importer code
696 and was a nice sounding board for API discussions.
697 Peter Rabbitson provided a sane git repository setup containing entire
699 package history.
700
702 A pile of requests from other people is still pending further
703 processing in my mailbox. This includes:
704 · List::Util export pass-through
706 Allow List::SomeUtils to pass-through the regular List::Util
708 functions to end users only need to "use" the one module.
709 · uniq_by(&@)
711 Use code-reference to extract a key based on which the uniqueness
713 is determined. Suggested by Aaron Crane.
714 · delete_index
716 · random_item
718 · random_item_delete_index
720 · list_diff_hash
722 · list_diff_inboth
724 · list_diff_infirst
726 · list_diff_insecond
728 These were all suggested by Dan Muey.
730 · listify
732 Always return a flat list when either a simple scalar value was
734 passed or an array-reference. Suggested by Mark Summersault.
735
737 List::Util, List::AllUtils, List::UtilsBy
738
740 Some parts copyright 2011 Aaron Crane.
741 Copyright 2004 - 2010 by Tassilo von Parseval
743 Copyright 2013 - 2015 by Jens Rehsack
745
747 Bugs may be submitted at
748 <https://github.com/houseabsolute/List-SomeUtils/issues>.
749 I am also usually active on IRC as 'autarch' on "irc://irc.perl.org".
751
753 The source code repository for List-SomeUtils can be found at
754 <https://github.com/houseabsolute/List-SomeUtils>.
755
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 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 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 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
775 · Tassilo von Parseval <tassilo.von.parseval@rwth-aachen.de>
776 · Adam Kennedy <adamk@cpan.org>
778 · Jens Rehsack <rehsack@cpan.org>
780 · Dave Rolsky <autarch@urth.org>
782
784 · Aaron Crane <arc@cpan.org>
785 · BackPan <BackPan>
787 · bay-max1 <34803732+bay-max1@users.noreply.github.com>
789 · Brad Forschinger <bnjf@bnjf.id.au>
791 · David Golden <dagolden@cpan.org>
793 · jddurand <jeandamiendurand@free.fr>
795 · Jens Rehsack <sno@netbsd.org>
797 · J.R. Mash <jrmash@cpan.org>
799 · Karen Etheridge <ether@cpan.org>
801 · Ricardo Signes <rjbs@cpan.org>
803 · Toby Inkster <mail@tobyinkster.co.uk>
805 · Tokuhiro Matsuno <tokuhirom@cpan.org>
807 · Tom Wyant <wyant@cpan.org>
809
811 This software is copyright (c) 2019 by Dave Rolsky <autarch@urth.org>.
812 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 The full text of the license can be found in the LICENSE file included
817 with this distribution.
818perl v5.32.0 2020-07-28 List::SomeUtils(3)