You can do it this way

push @{ $_ & 1 ? \@a : \@b }, $_ for 1 .. 10;

print "@a\n@b";

1 3 5 7 9
2 4 6 8 10
[download]

And the reason

print prototype( 'CORE::push' );

\@@
[download]

"In particular, if an element $_[0] is updated, the corresponding argument is updated (or an error occurs if it is not updatable). If an argument is an array or hash element which did not exist when the function was called, that element is created only when (and if) it is modified or a reference to it is taken...
...Assigning to the whole array @_ removes that aliasing, and does not update any arguments"

So, to do what you are attempting (which I personally feel is poor programming style), you need to manually vivify the elements you want updated, and you need to fill them one element at at time (cannot use array assignment).

The code segment below illustrates this:

# MODIFIED Second example; nothing gets assigned to @array1 or @array2
+ the first time, but DOES the second time
# But no compiletime errors are generated either:
my $condition = int rand 2;
sub testthis {
   my $i=0;
   # Note: assignment is element-by-element
   foreach $word( qw/This that and the other/){
       $_[$i] = $word;
       $i++;
   }
}
my ( @array1, @array2 );
testthis( $condition ? @array1 : @array2 );
print "With Empty arrays setting $condition: @array1,\n         @array
+2;\n";

@array1 = qw/no longer empty one/;
@array2 = qw/no longer empty two/;

testthis( $condition ? @array1 : @array2 );
print "With NON-Empty arrays setting $condition: @array1,\n         @a
+rray2;\n";
####################################
## Output ###
With Empty arrays setting 0: ,
         ;
With NON-Empty arrays setting 0: no longer empty one,
         This that and the;
[download]

Note - only the existing array indices are updated. New ones are NOT created.

It is true that the trinary operator can be used as an lvalue. On the other hand, I can't think of a legitimate reason why one would want to do so (although I'm open to suggestions).

As a first approximation, I think the expression is better written as

  if( $flag ) {
    $on = $value;
  }
  else {
    $off = $value;
  }
[download]

Then again, the repeated assignments of the same value does look a little redundant. This could be recast as

  ${$flag ? \$on : \$off} = $value;
[download]

Which, not coincidentally, looks remarkably similar to the problem of pushing to the correct array, and to my twisted mind, seems a bit easier to follow than the initial code. The fact that the code looks weird alerts you to the fact that something weird is indeed going on.

But I digress. I posited that one should never use the ternary operator as an lvalue. When I see code that does this, it is usually a degenerate (in more ways than one) form of a hash. I would probably recast the two scalars as keys of a hash, which would give something like:

  $status{$flag ? 'on' : 'off'} = $value;
[download]

That, to me, looks the clearest of all.

perl -we'upd(@x[0..2]); sub upd { @_[0..2] = "a".."c" } print @x'
abc
[download]

Just recently someone reported that constant folding is allowing something like this push((CONST ? @x : @y), "foo") to work. IMO, this is a bug and should not be relied upon.