I'm a little confused here... why would that trigger an unused warning? The variables in the calling code will be used, and the receiving function will be declaring its own, assigning out of @_, and discarding the rest, so it shouldn't have a problem either.

Could you post an example?

For example:

sub foo1 {
  my ($c, $d, $e, $f) = @_;
  return $d * f;
}

sub foo2 {
  my ($c, $d, $e, $f) = @_;
  return $c + $d + $e + $f;
}

sub do_foo {
  my $which = $_[0] ? \&foo1, \&foo2;
  $which->(1, 2, 3, 4);
}
[download]

As you see foo1 uses only uses the second argument and fourth ($d, $f). But the assignment happens via my ($c, $d, $e, $f) = @_;. If a warnings is introduced for lexical variables that are used once then it will warn. (lexicals $c and $e are declared and initialized but never used.

Yes, the assignment could be changed into: my ($d, $f) = @_[1, 3]; but this would be worse from a maintenance point of view.

With my ($c, $d, $e, $f) = @_; you know exactly what parameters are passed (assuming they get a decent name). If you use my ($d, $f) = @_[1, 3]; then you are clueless about the other arguments.
If you later need the other arguments then you need to start looking in what order they were passed.

What I'm not seeing is why you would think that $c or $e could have a name better than undef.

sub foo1 {
    my (undef, $d, undef, $f) = @_;
    return $d * $f;
}
[download]

... works just fine, produces no warnings, and has the added advantage of immediately giving the parameter a name that makes it absolutely clear that the value will be discarded.