In Perl, how can I implement map using grep? - perl

Question

Some time ago I was asked the “strange” question how would I implement map with grep.
Today I tried to do it, and here is what came out. Did I squeeze everything from Perl, or there are other more clever hacks?
#!/usr/bin/env perl
use strict;
use warnings;
use 5.010;
sub my_map(&#) {
grep { $_= $_[0]->($_) } #_[1..$#_];
}
my #arr = (1,2,3,4);
#list context
say (my_map sub {$_+1}, #arr);
#scalar context
say "".my_map {$_+1} #arr;
say "the array from outside: #arr";
say "builtin map:", (map {$_+1} #arr);

Answer 1

Are you sure they didn't ask how to implement grep with map? That's actually useful sometimes.
grep { STMTs; EXPR } LIST
can be written as
map { STMTs; EXPR ? $_ : () } LIST
(With one difference: grep returns lvalues, and map doesn't.)
Knowing this, one can compact
map { $_ => 1 } grep { defined } #list
to
map { defined ? $_ => 1 : () } #list
(I prefer the "uncompressed" version, but the "compressed" version is probably a little faster.)
As for implementing map using grep, well, you can take advantage of grep's looping and aliasing properties.
map { STMTs; EXPR } LIST
can be written as
my #rv;
grep { STMTs; push #rv, EXPR } LIST;
#rv

Answer 2

My attempt at this largely pointless academic exercise is.
sub my_map (&#) {
my $code = shift;
my #return_list;
grep {
push #return_list, $code->($_);
} #_;
return #return_list;
}
Using grep for this is a bit of a waste, because the return list of map may not be 1:1 with the input list, like my %hash = map { $_ => 1 } #array;, you need to be more generic that using the return list of grep. The result is any looking method that allows modifying the original list would work.
sub my_map (&#) {
my $code = shift;
my #return_list;
push #return_list, $code->($_) for #_;
return #return_list;
}

Answer 3

I'm not entirely sure what you mean (what aspect of mapist to be emulated by grep), but a typical map-scenario could be e.g. y = x**3:
...
my #list1 = (1,2,3,4,5);
my #list2 = map $_**3, #list1;
...
With grep, if you had to, you could almost make it looke like map (but destroying the original list):
...
my #list2 = grep { $_**=3; 1 } #list1;
...
by simply writing to the references of the original list elements. The problem here is the unwanted modification of the original list; this is what you don't want to do with map.
Therefore, we could just generate another list in a subroutine, modify this one and leave the original list untouched. In slight modification of Sinan Ünür's solution, this would read:
sub gap(&#) {
my $code = shift;
my #list = #_;
grep $_ = $code->($_), #list;
#list
}
my #arr = (1 .. 5);
# original map
print join ',', map { $_**3 } #arr;
# 1,8,27,64,125
# grep map
print join ',', gap { $_**3 } #arr;
# 1,8,27,64,125
# test original array
print join ',', #arr;
# 1,2,3,4,5 => untouched
Regards
rbo