Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

use v6.*;

module List::AllUtils:ver<0.0.6>:auth<zef:lizmat> {
    use List::Util:ver<0.0.10>:auth<zef:lizmat>;
    use List::MoreUtils:ver<0.0.9>:auth<zef:lizmat>;
    use List::UtilsBy:ver<0.0.7>:auth<zef:lizmat>;

    BEGIN {
        for
          List::Util::EXPORT::SUPPORTED::,
          List::MoreUtils::EXPORT::all::,
          List::UtilsBy::EXPORT::all::
        -> $stash {
            for $stash.grep(*.key.starts-with("&")) {
                trait_mod:<is>(
                  (List::AllUtils::{.key} = .value), # available externally
                  :SYMBOL(.key),                     # use this name, not own
                  :export(:all)                      # make it export with :all
                ) unless List::AllUtils::{.key}:exists;  # if we don't have one
            }
        }
    }
}

sub EXPORT(*@args, *%_) {
    if @args {
        my $imports := Map.new( |(EXPORT::all::{ @args.map: '&' ~ * }:p) );
        if $imports != @args {
            die "List::AllUtils doesn't know how to export: "
              ~ @args.grep( { !$imports{$_} } ).join(', ')
        }
        $imports
    }
    else {
        Map.new
    }
}



Raku port of Perl's List::AllUtils module 0.14


# _Everything_ from List::Util, List::MoreUtils, and List::UtilsBy
use List::AllUtils qw( :all );


my @numbers = ( 1, 2, 3, 5, 7 );
# or don't import anything
return List::AllUtils::first { $_ > 5 } @numbers;


This module tries to mimic the behaviour of Perl's C<List::AllUtils> module
as closely as possible in the Raku Programming Language.


Are you sick of trying to remember whether a particular helper is
defined in L<List::Util>,  L<List::MoreUtils> or L<List::UtilsBy>? Now you
don't have to remember. This module will export all of the functions
that either of those three modules defines.


C<List::AllUtils> always favors the version provided by L<List::Util>,
L<List::MoreUtils> or L<List::UtilsBy> in that order.


Rather than copying the documentation and running the risk of getting out of
date, please check the original documentation using the following mapping:


all any first max maxstr min minstr none notall pairfirst pairgrep pairkeys
pairmap pairs pairvalues product reduce shuffle sum sum0 uniq uniqnum uniqstr
unpairs


after after_incl all_u any_u apply arrayify before before_incl binsert
bremove bsearch bsearch_index bsearch_insert bsearch_remove bsearchidx
distinct duplicates each_array each_arrayref equal_range false first_index
first_result first_value firstidx firstres firstval frequency indexes
insert_after insert_after_string last_index last_result last_value lastidx
lastres lastval listcmp lower_bound mesh minmax minmaxstr mode natatime
none_u notall_u nsort_by occurrences one one_u only_index only_result
only_value onlyidx onlyres onlyval pairwise part qsort reduce_0 reduce_1
reduce_u samples singleton sort_by true upper_bound zip zip6 zip_unflatten


bundle_by count_by extract_by extract_first_by max_by min_by minmax_by
nmax_by nmin_by nminmax_by partition_by rev_nsort_by rev_sort_by uniq_by
unzip_by weighted_shuffle_by zip_by


Source can be located at: https://github.com/lizmat/List-AllUtils . Comments
and Pull Requests are welcome.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


Re-imagined from the Perl version as part of the CPAN Butterfly Plan. Perl
version developed by Dave Rolsky.


AllUtils

unit module List::Allmax;

sub all-max (*@list, Callable :&by = {$_}, :$k = False) is export  {
    if @list.is-lazy { X::Cannot::Lazy.new(action =>'all-max').throw }
    my @max-list;
    my $max = @list[0];
    my &comp = { &by($^a) cmp &by($^b) }
    if $k {
        for ^@list {
            if comp(@list[$_], $max) == 0 {
                @max-list.push: $_;
            } elsif comp(@list[$_], $max) > 0 {
                $max = @list[$_];
                @max-list = $_
            }
        }
    } else {
        for @list {
            if comp($_, $max) == 0 {
                @max-list.push: $_;
            } elsif comp($_, $max) > 0 {
                $max = $_;
                @max-list = $_
            }
        }
    }
    @max-list
}

sub all-min (*@list, Callable :&by = {$_}, :$k = False) is export  {
    if @list.is-lazy { X::Cannot::Lazy.new(action =>'all-min').throw }
    my @min-list;
    my $min = @list[0];
    my &comp = { &by($^a) cmp &by($^b) }
    if $k {
        for ^@list {
            if comp(@list[$_], $min) == 0 {
                @min-list.push: $_;
            } elsif comp(@list[$_], $min) < 0 {
                $min = @list[$_];
                @min-list = $_
            }
        }
    } else {
        for @list {
            if comp($_, $min) == 0 {
                @min-list.push: $_;
            } elsif comp($_, $min) < 0 {
                $min = $_;
                @min-list = $_
            }
        }
    }
    @min-list
}




List::Allmax - Find all of the maximum or minimum elements of a list.


=begin code :lang<raku>

use List::Allmax;

say (^20).roll(50).&all-max;     # values

say (^20).roll(50).&all-min: :k; # keys

say [1,2,3,4,5,5,4,3,2,1,2,2,5,4,4].classify({$_}).sort.List.&all-max( :by(+*.value) );
# [2 => [2,2,2,2], 4 => [4,4,4,4]]

=end code


Raku provides C<max> and C<min> routines to find the maximum or minimum elements of a
list. If there is more than one value that evaluates to the maximum, (minimum)
only the first is reported, no matter how many there may be. This module
provides a remedy for that.


Provides the routines C<all-max()> and C<all-min()> that return _all_ of the elements
that evaluate to maximum or minimum value.


Similar to the built-ins, you may request either a list of values or a list of
indicies (keys) where those values are located.


If you want to compare based on something other than the values of the
individual elements, supply a named C<:by()> Callable block to be used as an
evaluator. Defaults to C<{$_}> (self).


Note: Only operates on Positional objects. If want to use it on a Hash or some
other Associative type, coerce to a Listy type object first.


Stephen Schulze (aka thundergnat <thundergnat@comcast.net>)


Allmax

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

AUTHOR

COPYRIGHT AND LICENSE

List::Allmax v0.0.1

Authors

License

Dependencies

Test Dependencies

Provides

Documentation