NAME List::MapMulti - map through multiple arrays at once SYNOPSIS use feature qw/say/; use List::MapMulti qw/mapm/; my @numbers = (2..10, qw/Jack Queen King Ace/); my @suits = qw/Clubs Diamonds Hearts Spades/; my @cards = mapm { "$_[0] of $_[1]" } \@numbers, \@suits; say scalar(@cards); # says '52' say $cards[0]; # says '2 of Clubs' say $cards[1]; # says '2 of Diamonds' say $cards[-1]; # says 'Ace of Spades' DESCRIPTION List::MapMulti provides shortcuts for looping through several lists in a nested fashion. Think about all the times you've needed to do something like: foreach my $x (@exes) { foreach my $y (@whys) { # do something with $x and $y } } There are two different solutions available to you: `map_multi` (which has an alias `mapm`) and `iterator_multi`. The only thing this module exports by default is `mapm`. `map_multi { BLOCK } \@list1, \@list2 ...` (Or `mapm`!) Calls the codeblock with every possible combination of values from each list. If you imagine it as calling within a set of nested loops, then the final list is the innermost loop; and the first loop is the outermost loop. Note that within the codeblock, the items from each list are available as $_[0], $_[1], etc. The $_ variable is set to a List::MapMulti::Iterator object which is used internally by `map_multi`. For the special (but common) case where you're just mapping over two lists, $a and $b are aliased to $_[0] and $_[1]. You may need to do `our ($a, $b)` to suppress warnings about variables being used only once. `mapm` is exported by default, but `map_multi` needs to be requested explicitly. `iterator_multi(\@list1, \@list2, ...)` This allows constructions like this: my $iterator = iterator_multi(\@numbers, \@suits); while (my ($number, $suit) = $iterator->()) { say "$number of $suit"; } Although `map_multi` is arguably a nicer syntax, the iterator provides you with an important advantage: you don't have to iterate through every possible combination. You can control flow using, say, `next`, `last` or `redo`. List::MapMulti::Iterator This is advanced fu that you probably don't need to know about. While iterators act like coderefs (you get the next set of values via `$iterator->()`), internally they are blessed objects that overload `&{}`. As they are objects, they are able to provide some methods. These are the methods they provide: `new(\@list1, \@list2, ...)` Constructor. The `iterator_multi` function is just a shortcut for this. `next` Calling `$iterator->next` is exactly equivalent to calling `$iterator->()`. `current` Returns the same thing as the previous call to `next` (unless the original arrays have changed since then). This can also be used as a setter, in which case it writes back to the appropriate slots in the original arrays. `next_indices` Returns the array indices that will be used to read from the original arrays next time `next` is called. Again, this can be used as a setter. `current_indices` Returns the array indices that was used to read from the original arrays last time `next` was called. BUGS Please report any bugs to . SEE ALSO List::Util, List::MoreUtils, List::Pairwise. AUTHOR Toby Inkster . COPYRIGHT AND LICENCE This software is copyright (c) 2012 by Toby Inkster. This is free software; you can redistribute it and/or modify it under the same terms as the Perl 5 programming language system itself. DISCLAIMER OF WARRANTIES THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.