use List::MoreUtils qw/firstidx/;

my $from = firstidx {$_ eq $look_for} @array;
return @array[$from+1..$#array];
[download]

Because  firstidx returns -1 if the test block never evaluates true, a test is needed avoid returning all elements if the looked-for element is not found:
    my $from = firstidx {$_ eq $look_for} @array;
    return unless $from > -1;
    return @array[$from+1..$#array];

sub after{ my $target=shift; shift @_ until $_[0] eq $target; return @
+_ };;
@a = 'a'..'z';;

print after( 'm', @a );;
m n o p q r s t u v w x y z

print after( 'e', @a );;
e f g h i j k l m n o p q r s t u v w x y z

print after( 'y', @a );;
y z
[download]

Add another shift if you don't want the element you looked for.

So far all approaches seem to avoid the flip-flop.

It would be very curious to see if there is a way to reset the flip-flop in some sane way (you probably need to create a new closure to use in the grep every time you call it or something).

This was one of the very few times I tried to make use of the flip-flop and more or less every time I try to use it I have to abandon it in the end.

Because of this global-state issue the flip-flop is pretty much useless to me - to the point where I think perl would be better off without it...

Because of this global-state issue the flip-flop is pretty much useless to me

My take is that the flip-flop is very useful for one-liners were is compactness is invaluable, and I wouldn't want to lose that.

But I cannot remember the last time I used in a script. What it does can always be done better -- though more verbosely -- when you have the space.

---

With the rise and rise of 'Social' network sites: 'Computers are making people easier to use everyday'

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

The start of some sanity?

One way to "reset" the flip-flop is to recompile its statement.

use strict;
my @a = qw(hubba bubba abba zappa);
print blah("bubba", @a), "\n";
print blah("bubba", @a), "\n";

sub blah {
    my($look_for, @array)=@_;
    
    my @elements_we_want;
    my $string = 
        '(undef, @elements_we_want) = grep { $_ eq $look_for .. 1 } @a
+rray;';
    eval $string;
    
    return @elements_we_want;
}
[download]

Edit: Sorry, I did not notice the similiar idea by JavaFan.

$ perl -Mstrict -Mwarnings -E '
> my @x = (0 .. 10);
> my @y = grep { state $z = 0; $_ == 3 and $z = 1; $z } @x;
> say qq{@y};
> '
3 4 5 6 7 8 9 10
[download]

Sorry. Crap answer - see JavaFan's comments (below) for the reason why. Only read the first half of the question. Here's a better answer, in the same vein.

$ perl -Mstrict -Mwarnings -E '
> sub blah { my $z = 0; [ grep { /3/ and $z = 1; $z } @_ ] }
> my @x = (0 .. 10);
> say qq{@{blah(@x)}};
> my @y = qw{a b c 3 d e f};
> say qq{@{blah(@y)}};
> '
3 4 5 6 7 8 9 10
3 d e f
[download]

Suffers from the same problem the OP describes. If you would use that grep a second time (because it's in a sub, or in a loop), the $z doesn't get reset -- that's what state is doing.

Better (but untested):

my @y = do {my $z = 0; grep {$z ||= $_ == 3} @x};
[download]

Note that doesn't evaluate the condition ($_ == 3) after finding a match.

++ Thanks JavaFan, I've updated my post.

-- Ken

My first success at resetting the flip-flop:

#!/usr/bin/perl -l

sub after {
    my $skip = shift @_;
    my( undef, @want ) = grep {
        $_ eq $skip .. ref($_) && $_ == \$skip
    } @_, \$skip;
    pop @want;
    return @want;
}

print join ", ", after(qw< c a b c d e f g >);
print join ", ", after(qw< e a b c d e f g >);
print join ", ", after(qw< z a b c d e f g >);
print join ", ", after(qw< f a b c d e f g >);
print join ", ", after(qw< g a b c d e f g >);
print join ", ", after(qw< a a b c d e f g >);
__END__
d, e, f, g
f, g

g

b, c, d, e, f, g
[download]

Not that I'd find myself likely to actually use such a thing, even with my more elegant solution:

#!/usr/bin/perl -l

sub after {
    my $skip = shift @_;
    my( undef, @i ) = grep $_[$_] eq $skip .. $_ == $#_, 0..$#_;
    return @_[@i];
}

print join ", ", after(qw< c a b c d e f g >);
print join ", ", after(qw< e a b c d e f g >);
print join ", ", after(qw< z a b c d e f g >);
print join ", ", after(qw< f a b c d e f g >);
print join ", ", after(qw< g a b c d e f g >);
print join ", ", after(qw< a a b c d e f g >);
__END__
d, e, f, g
f, g

g

b, c, d, e, f, g
[download]

sub blah {
    my $look_for = shift;
    my (undef, @a) = eval 'grep {$_ eq $look_for .. /(*FAIL)/} @_';
    @a;
}
[download]

I didn't know that if the right hand (reset) expression doesn't match, flip-flop to keep it's state, like closure.

How about putting sentinel to the list, which surely reset flip-flop state?

sub blah3 { 
my($look_for, @array)=@_; 

my @elements_we_want = 
    grep { $_ eq $look_for .. $_ eq 'MY SENTINEL'} @array,'MY SENTINEL
+';
return @elements_we_want[ 1 .. $#elements_we_want -1]; 
}
[download]

sub after{
    my $look_for = shift;

    my $i = 0;
    my $x = -@_;

    while(++$x){
        return @_[$i..$#_] if $_[$i++] eq $look_for;
    }
    return;
}

@a = 'a'..'z';;
print after( 'm', @a );
# n o p q r s t u v w x y z
[download]