It is false as long as its left operand is false. Once the left operand is true, the range operator stays true until the right operand is true, AFTER which the range operator becomes false again. It doesn't become false till the next time the range operator is evaluated. It can test the right operand and become false on the same evaluation it became true (as in awk), but it still returns true once. If you don't want it to test the right operand until the next evaluation, as in sed, just use three dots ("...") instead of two.

I am assuming here that Perl processes each array element char by char "from left to right"

On the first pass through the loop, the flip-flop's state is false, so ca is tested against /a/, which matches, so it returns true, but it also tests against /c/ which resets it to false. From perldoc perlop:

Once the left operand is true, the range operator stays true until the right operand is true, AFTER which the range operator becomes false again. It doesn't become false till the next time the range operator is evaluated. It can test the right operand and become false on the same evaluation it became true (as in awk), but it still returns true once. If you don't want it to test the right operand until the next evaluation, as in sed, just use three dots ("...") instead of two. In all other regards, "..." behaves just like ".." does.

Yes, I have read all those articles on the internet. But nowhere was described this counterintuitive behaviour. Of course, they point out that perl -we'my @l = qw/ac qw/; for (@l) { print if /a/../c/ }' would print ac and the same only with three dots prints acqw. This is completely understandable but not the case with @l = qw/ca qw/. Maybe it's really better to avoid such constructs as other monk has said.

I have read all those articles on the internet. But nowhere was described this counterintuitive behaviour.

Maybe it's just me, but perldoc's "It can test the right operand and become false on the same evaluation it became true (as in awk), but it still returns true once." seems to describe exactly this behavior. I'd even call it a clear description.

they point out that perl -we'my @l = qw/ac qw/; for (@l) { print if /a/../c/ }' would print ac and the same only with three dots prints acqw. This is completely understandable but not the case with @l = qw/ca qw/.

I don't get what you mean here. qw/ac qw/ and qw/ca qw/ are treated identically by the flip-flop operator:

$ perl -E 'my @l = qw/ac qw/; for (@l) { say if /a/../c/ }'
ac
$ perl -E 'my @l = qw/ca qw/; for (@l) { say if /a/../c/ }'
ca
[download]

And, in my humble opinion, the “flip-flop operator” is one of the total flops in the legacy design of Perl.   I studiously avoid using it, partly because I have been so badly bitten by code that did use it.   When I stumble upon it, I excise it.   Perl incorporates many clever and useful ideas, but this one is a turkey, because (as you see for yourself) you cannot “glance” at the code and immediately see at a glance what it will actually do.   I choose to instead to write a “boring, old, space-wasting” if-statement block that “obviously” describes what I want the computer to do.

I really don’t want to start any sort of “flame war” here; it would be pointless to all.   Up/Down votes will more than suffice.