E.g., does perl avoid copying of data in the following cases?

No. The array is copied in both those cases.

There are two ways of avoiding that:

1. Return an arrayref as in your second example and use it as an array ref in the calling code:

   sub large_array_ref {
     my $large_array_ref = [];
     ...populate @$large_array_ref...
     return $large_array_ref;
   }
   
   my $c = large_array_ref();
   
   $c->[ ... ];
   [download]

2. Pass an array ref into your sub:

   sub large_array_ref {
     my $large_array_ref = shift;
     ...populate @$large_array_ref...
     return;
   }
   
   large_array_ref( \my @c );
   
   $c[ ... ];
   [download]

   With a suitably chosen name for the sub, the latter looks less awkward:

   populateThingArray( \my @c );
   
   $c[ ... ];
   [download]

> With a suitably chosen name for the sub, the latter looks less awkward:

populateThingArray( \my @c ); 
 
$c[ ... ];
[download]

as a side note, one can use the fat comma for syntactic sugar:

calcArrays( $par1, $par2 => \ my (@a,@b) );

Cheers Rolf

Update: extended code to return multiple Arrays.

Perl does not employ a copy-on-write mechanism. As such, assigning a one array to another (as in the second example) involves copying the elements, not just copying a reference to the elements.

In the first example, you're not even assigning an array to an array. You're getting a list of the elements in the array, then you're assigning that list to another array. You might end up copying each element twice! I know there's at least one optimisation in place, but there's no escaping copying each element at least once for the reason I gave above.

Did the OP, or anyone, ever, suggest that Perl might use a "copy-on-write mechanism"?

You seem to have misunderstood what I said. Whether copying occurs in an array to array assignment or not depends on whether Perl does COW or not. If it does, copying can be avoided. If it doesn't copying must occur. It doesn't, so copying must occur. And thus, the OP's question is answered.

Pass around a reference to the result array.   A reference (to anything...) occupies only one small slot on the runtime stack.

Bear in mind that changes to any reference to “the same thing” will be reflected in all references to that “thing.”   If you need to make a deep copy of whatever the reference points to, there are several ways to do that, e.g. dclone() in Storable.