File Coverage

blib/lib/List/MapList.pm

Criterion	Covered	Total	%
statement	20	20	100.0
branch	2	2	100.0
condition			n/a
subroutine	7	7	100.0
pod	2	2	100.0
total	31	31	100.0

use strict;
use warnings;
package List::MapList 1.124;
# ABSTRACT: map lists through a list of subs, not just one

use Exporter 5.57 'import';
our @EXPORT = qw(mapcycle maplist); ## no critic

#pod =head1 SYNOPSIS
#pod
#pod Contrived heterogenous transform
#pod
#pod  use List::MapList;
#pod
#pod  my $code = [
#pod    sub { $_ + 1 },
#pod    sub { $_ + 2 },
#pod    sub { $_ + 3 },
#pod    sub { $_ + 4 }
#pod  ];
#pod
#pod  my @mapped_1 = maplist( $code, qw(1 2 3 4 5 6 7 8 9));
#pod  # @mapped_1 is qw(2 4 6 8)
#pod
#pod  my @mapped_2 = mapcycle( $code, qw(1 2 3 4 5 6 7 8 9));
#pod  # @mapped_2 is qw(2 4 6 8 6 8 10 12 13)
#pod
#pod Ultra-secure partial rot13:
#pod
#pod  my $rotsome = [
#pod   sub { tr/a-zA-Z/n-za-mN-ZA-M/; $_ },
#pod   sub { tr/a-zA-Z/n-za-mN-ZA-M/; $_ },
#pod   sub { $_ },
#pod  ];
#pod
#pod  my $plaintext  = "Too many secrets.";
#pod  my $cyphertext = join '', mapcycle($rotsome, split //, $plaintext);
#pod
#pod =head1 DESCRIPTION
#pod
#pod List::MapList provides methods to map a list through a list of transformations,
#pod instead of just one.  The transformations are not chained together on each
#pod element; only one is used, alternating sequentially.
#pod
#pod Here's a contrived example: given the transformations C<{ $_ = 0 }> and C<{ $_
#pod = 1 }>, the list C<(1, 2, 3, "Good morning", undef)> would become C<(0, 1, 0, 1,
#pod 0)> or, without cycling, C<(0, 1)>.;
#pod
#pod (I use this code to process a part number in which each digit maps to a set of
#pod product attributes.)
#pod
#pod =func maplist
#pod
#pod   my @results = maplist(\@coderefs, LIST);
#pod
#pod This routine acts much like a normal C, but uses the list of code
#pod references in C<$coderefs> in parallel with the list members.  First first code
#pod reference is used for the first list member, the next for the second, and so
#pod on.  Once the last code reference has been used, all further elements will be
#pod mapped to C<()>.
#pod
#pod =cut

sub maplist {
  my ($subs, $current) = (shift, 0);
  my $code = sub { $subs->[$current++] || sub { () }; };
  map { $code->()->() } @_;
}

#pod =func mapcycle
#pod
#pod   my @results = mapcycle($coderefs, LIST);
#pod
#pod This routine is identical to C, but will cycle through the passed
#pod coderefs over and over as needed.
#pod
#pod =cut

sub mapcycle {
  my ($subs, $current) = (shift, 0);
  my $code = sub { $subs->[$current++ % @$subs]; };
  map { $code->()->() } @_;
}

1;

__END__