X-Git-Url: http://wagnertech.de/git?p=kivitendo-erp.git;a=blobdiff_plain;f=doc%2Fmodules%2FREADME.List-UtilsBy;fp=doc%2Fmodules%2FREADME.List-UtilsBy;h=0000000000000000000000000000000000000000;hp=efdceb3106982a62ee7ec0fe64431749334d9782;hb=53593baa211863fbf66540cf1bcc36c8fb37257f;hpb=deb4d2dbb676d7d6f69dfe7815d6e0cb09bd4a44 diff --git a/doc/modules/README.List-UtilsBy b/doc/modules/README.List-UtilsBy deleted file mode 100644 index efdceb310..000000000 --- a/doc/modules/README.List-UtilsBy +++ /dev/null @@ -1,238 +0,0 @@ -NAME - `List::UtilsBy' - higher-order list utility functions - -SYNOPSIS - use List::UtilsBy qw( nsort_by min_by ); - - use File::stat qw( stat ); - my @files_by_age = nsort_by { stat($_)->mtime } @files; - - my $shortest_name = min_by { length } @names; - -DESCRIPTION - This module provides a number of list utility functions, all of which - take an initial code block to control their behaviour. They are - variations on similar core perl or `List::Util' functions of similar - names, but which use the block to control their behaviour. For example, - the core Perl function `sort' takes a list of values and returns them, - sorted into order by their string value. The `sort_by' function sorts - them according to the string value returned by the extra function, when - given each value. - - my @names_sorted = sort @names; - - my @people_sorted = sort_by { $_->name } @people; - -FUNCTIONS - @vals = sort_by { KEYFUNC } @vals - Returns the list of values sorted according to the string values - returned by the `KEYFUNC' block or function. A typical use of this may - be to sort objects according to the string value of some accessor, such - as - - sort_by { $_->name } @people - - The key function is called in scalar context, being passed each value in - turn as both `$_' and the only argument in the parameters, `@_'. The - values are then sorted according to string comparisons on the values - returned. - - This is equivalent to - - sort { $a->name cmp $b->name } @people - - except that it guarantees the `name' accessor will be executed only once - per value. - - One interesting use-case is to sort strings which may have numbers - embedded in them "naturally", rather than lexically. - - sort_by { s/(\d+)/sprintf "%09d", $1/eg; $_ } @strings - - This sorts strings by generating sort keys which zero-pad the embedded - numbers to some level (9 digits in this case), helping to ensure the - lexical sort puts them in the correct order. - - @vals = nsort_by { KEYFUNC } @vals - Similar to `sort_by' but compares its key values numerically. - - @vals = rev_sort_by { KEYFUNC } @vals - @vals = rev_nsort_by { KEYFUNC } @vals - Similar to `sort_by' and `nsort_by' but returns the list in the reverse - order. Equivalent to - - @vals = reverse sort_by { KEYFUNC } @vals - - except that these functions are slightly more efficient because they - avoid the final `reverse' operation. - - $optimal = max_by { KEYFUNC } @vals - @optimal = max_by { KEYFUNC } @vals - Returns the (first) value from `@vals' that gives the numerically - largest result from the key function. - - my $tallest = max_by { $_->height } @people - - use File::stat qw( stat ); - my $newest = max_by { stat($_)->mtime } @files; - - In scalar context, the first maximal value is returned. In list context, - a list of all the maximal values is returned. This may be used to obtain - positions other than the first, if order is significant. - - If called on an empty list, an empty list is returned. - - For symmetry with the `nsort_by' function, this is also provided under - the name `nmax_by' since it behaves numerically. - - $optimal = min_by { KEYFUNC } @vals - @optimal = min_by { KEYFUNC } @vals - Similar to `max_by' but returns values which give the numerically - smallest result from the key function. Also provided as `nmin_by' - - @vals = uniq_by { KEYFUNC } @vals - Returns a list of the subset of values for which the key function block - returns unique values. The first value yielding a particular key is - chosen, subsequent values are rejected. - - my @some_fruit = uniq_by { $_->colour } @fruit; - - To select instead the last value per key, reverse the input list. If the - order of the results is significant, don't forget to reverse the result - as well: - - my @some_fruit = reverse uniq_by { $_->colour } reverse @fruit; - - %parts = partition_by { KEYFUNC } @vals - Returns a key/value list of ARRAY refs containing all the original - values distributed according to the result of the key function block. - Each value will be an ARRAY ref containing all the values which returned - the string from the key function, in their original order. - - my %balls_by_colour = partition_by { $_->colour } @balls; - - Because the values returned by the key function are used as hash keys, - they ought to either be strings, or at least well-behaved as strings - (such as numbers, or object references which overload stringification in - a suitable manner). - - %counts = count_by { KEYFUNC } @vals - Returns a key/value list of integers, giving the number of times the key - function block returned the key, for each value in the list. - - my %count_of_balls = count_by { $_->colour } @balls; - - Because the values returned by the key function are used as hash keys, - they ought to either be strings, or at least well-behaved as strings - (such as numbers, or object references which overload stringification in - a suitable manner). - - @vals = zip_by { ITEMFUNC } \@arr0, \@arr1, \@arr2,... - Returns a list of each of the values returned by the function block, - when invoked with values from across each each of the given ARRAY - references. Each value in the returned list will be the result of the - function having been invoked with arguments at that position, from - across each of the arrays given. - - my @transposition = zip_by { [ @_ ] } @matrix; - - my @names = zip_by { "$_[1], $_[0]" } \@firstnames, \@surnames; - - print zip_by { "$_[0] => $_[1]\n" } [ keys %hash ], [ values %hash ]; - - If some of the arrays are shorter than others, the function will behave - as if they had `undef' in the trailing positions. The following two - lines are equivalent: - - zip_by { f(@_) } [ 1, 2, 3 ], [ "a", "b" ] - f( 1, "a" ), f( 2, "b" ), f( 3, undef ) - - The item function is called by `map', so if it returns a list, the - entire list is included in the result. This can be useful for example, - for generating a hash from two separate lists of keys and values - - my %nums = zip_by { @_ } [qw( one two three )], [ 1, 2, 3 ]; - # %nums = ( one => 1, two => 2, three => 3 ) - - (A function having this behaviour is sometimes called `zipWith', e.g. in - Haskell, but that name would not fit the naming scheme used by this - module). - - $arr0, $arr1, $arr2, ... = unzip_by { ITEMFUNC } @vals - Returns a list of ARRAY references containing the values returned by the - function block, when invoked for each of the values given in the input - list. Each of the returned ARRAY references will contain the values - returned at that corresponding position by the function block. That is, - the first returned ARRAY reference will contain all the values returned - in the first position by the function block, the second will contain all - the values from the second position, and so on. - - my ( $firstnames, $lastnames ) = unzip_by { m/^(.*?) (.*)$/ } @names; - - If the function returns lists of differing lengths, the result will be - padded with `undef' in the missing elements. - - This function is an inverse of `zip_by', if given a corresponding - inverse function. - - @vals = extract_by { SELECTFUNC } @arr - Removes elements from the referenced array on which the selection - function returns true, and returns a list containing those elements. - This function is similar to `grep', except that it modifies the - referenced array to remove the selected values from it, leaving only the - unselected ones. - - my @red_balls = extract_by { $_->color eq "red" } @balls; - - # Now there are no red balls in the @balls array - - This function modifies a real array, unlike most of the other functions - in this module. Because of this, it requires a real array, not just a - list. - - This function is implemented by invoking `splice()' on the array, not by - constructing a new list and assigning it. One result of this is that - weak references will not be disturbed. - - extract_by { !defined $_ } @refs; - - will leave weak references weakened in the `@refs' array, whereas - - @refs = grep { defined $_ } @refs; - - will strengthen them all again. - - @vals = weighted_shuffle_by { WEIGHTFUNC } @vals - Returns the list of values shuffled into a random order. The - randomisation is not uniform, but weighted by the value returned by the - `WEIGHTFUNC'. The probabilty of each item being returned first will be - distributed with the distribution of the weights, and so on recursively - for the remaining items. - - @vals = bundle_by { BLOCKFUNC } $number, @vals - Similar to a regular `map' functional, returns a list of the values - returned by `BLOCKFUNC'. Values from the input list are given to the - block function in bundles of `$number'. - - If given a list of values whose length does not evenly divide by - `$number', the final call will be passed fewer elements than the others. - -TODO - * XS implementations - These functions are currently all written in pure perl. Some at - least, may benefit from having XS implementations to speed up their - logic. - - * Merge into List::Util or List::MoreUtils - This module shouldn't really exist. The functions should instead be - part of one of the existing modules that already contain many list - utility functions. Having Yet Another List Utilty Module just - worsens the problem. - - I have attempted to contact the authors of both of the above - modules, to no avail; therefore I decided it best to write and - release this code here anyway so that it is at least on CPAN. Once - there, we can then see how best to merge it into an existing module. - -AUTHOR - Paul Evans