use Carp;
...
sub mysub {
    croak "Too many arguments for mysub" if @_ > $limit;
    ...
}
[download]

Why do you think that you need this feature?

What keeps you from checking the size of @_ in the subroutine?

sub iWantFourArguments
{
  @_==4 or die "Call me with four arguments. Died";
  # ...
}
[download]

Note that prototypes won't help you here, you can bypass them using &subname(...) and they aren't checked at all when subs are invoked as methods.

Alexander

Maybe like this?  (You didn't say what is supposed to happen if there are more than a certain number of arguments, i.e. ignore, warn, die,... at runtime or compile-time...)

#!/usr/bin/perl

sub foo {
    $#_ = 3 if @_ > 3;  # limit to 4 args
    print "$_\n" for @_;
    print "---\n";
}

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

__END__
1
2
3
---
1
2
3
4
---
1
2
3
4
---
[download]

(obviously, what I've shown implements the 'ignore' variant)

Or

#!/usr/bin/perl -w

use strict;

use Params::Validate qw' validate_pos ';

Main( @ARGV );
exit( 0 );

sub Foo
{
  validate_pos( @_, 1, 1, 1 );
  print "$_\n" for @_;
  print "---\n";
}


sub Main
{
  Foo(1,2,3);
  Foo(1,2,3,4);
  Foo(1,2,3,4,5);
}
__END__

1
2
3
---
1
2
3
---
4 parameters were passed to main::Foo but 3 were expected
 at - line 12
        main::Foo(1, 2, 3, 4) called at - line 21
        main::Main() called at - line 7
[download]

Can we strict the subroutine in perl to receive number of arguments ?

Runtime is easy:

sub foo {
    unless (@_ <= 4) {
        die "foo allows at most 4 arguments";
    }
    ...
}
[download]

sub foo (;$$$$) {
    ...
}
[download]

@bar = qw[red blue green yellow brown pink];
foo @bar;
[download]

thanks for your replies. I need to handle this in compile time only. But as Alexander told we can bypass this by calling the subroutine as &subroutine(..). Is there way to handle this ?

Can you explain why you "need" to do that?
--
A math joke: r = | |csc(θ)|+|sec(θ)|-||csc(θ)|-|sec(θ)|| |
Online Fortune Cookie Search
Office Space merchandise

But as Alexander told we can bypass this by calling the subroutine as &subroutine(..). Is there way to handle this ?

Not on the level of Perl itself. You may be able to do something by inspecting the op-tree. Perhaps perlcritic can help you as well, but that requires a separate stage.