Is there any chance that I could tell perl to ignore my past foolishness, and just forget that there is '($:$$)'?

For individual calls, you can bypass prototypes by calling the sub with the old ampersand syntax. See also Prototypes. If however this sub is being called in lots of places, instead of adding a bunch of &s, I would strongly recommend some refactoring of the code instead.

package Somename;
use Data::Dumper;
foo(1,2,3,4,5);
sub foo($;$$) { print Dumper(\@_) }

package main;
&Somename::foo(1,2,3,4,5);  # works
[download]

I should mention of course that a sub with a prototype ($;$$) and then shifting five arguments is quite a strange piece of code.

The prototype can be ignored by using &.

&foo( 1, 2, 3, 4, 5 )
[download]

"Import" without prototype:

sub foo { goto &Somename::foo }
[download]

But for the general case, you can always write a wrapper which calls the original

use v5.12.0;
use warnings;

package Somename;
use Data::Dumper;


foo(1,2,3,4,5);

sub foo($;$$) {

    my $one = shift;
    my $two = shift;
    my $three = shift;
    my $four = shift;
    my $five = shift;
    print Dumper [$four,$five];
}

package Othername;

# use Somename;

sub foo { &Somename::foo }  

foo(1..5);
[download]

Somename::foo() called too early to check prototype at d:/Perl/pm/foo_
+prototype.pl line 8.
$VAR1 = [
          4,
          5
        ];
$VAR1 = [
          4,
          5
        ];

Compilation finished at Sat Apr 15 00:12:57
[download]

Explanation for &Somename::foo

• the & helps ignoring the prototype
• the missing brackets mean it's called with the current @_
• the last position means it's return value is returned too.

Why don't you just remove the prototype?

use v5.12.0;
use warnings;

package Somename;
use Data::Dump qw/pp dd/;


foo(1,2,3,4,5);

sub foo {
    my $one = shift;
    my $two = shift;
    my $three = shift;
    my $four = shift;
    my $five = shift;

    pp $four,$five;
}
[download]

(4, 5)

FWIW: your old code produced a warning that you apparently ignored in the past°

Somename::foo() called too early to check prototype at d:/Perl/pm/foo_prototype.pl line 8.

removing the protoytpe will help you getting rid of this too.

°) or you didn't use warnings

Why don't you just remove the prototype?

I'd be careful with that, OP says this is legacy code, and simply removing the prototype could change how the code behaves at call sites that the OP doesn't want to affect. The $ prototype doesn't just mean "accept one argument", it also means "force scalar context on this argument".

my @ary = ("a","b","c");
sub foo($;$$) { print Dumper(\@_) }
sub foo2      { print Dumper(\@_) }
foo (@ary, ("x","y"), "z"); # @_ is [3, 'y', 'z' ]
foo2(@ary, ("x","y"), "z"); # @_ is ['a', 'b', 'c', 'x', 'y', 'z']
[download]

I was thinking to add a longer explanation about exactly that, but the OP said it's legacy code she wrote herself.

And I really doubt she tried to impose scalar context on the arguments, especially when it was always called before the prototype was declared.

Anyway since she never exported it so far, she can easily check the module for all calls.

Cheers Rolf
_{(addicted to the 𐍀𐌴𐍂𐌻 Programming Language :)
Wikisyntax for the Monastery}