I asked a similar question at the end of Re^5: Gratuitous use of Perl Prototypes but never received an answer.

Also, I originally used the same approach in Re: More functional programming utilities, but eventually decided for that purpose that multimap \( @a, @b, @c, @d, ... ); was preferable as it meant I could pass anonymous arrays and other similar constructs. Eg. multimap [...],[...];, whereas the prototype version insists upon real arrays.

Still no answer, but thanks++ for the interesting links!

sub each_array (\@;\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@\@) {
[download]

Anno

Indeed. I also found the "enough" syntax, but it looked so wrong that I didn't even dare to ask about it. Thanks++ for the answer anyway.

I happen to know the author of List::MoreUtils Usenet-wise and I know he'd search far and wide before letting this uglines stand in a module. If there was a better solution, Tassilo would have found it.

Anno

Even if you are aware, maybe it is good to remember: "Don't use prototypes". Except in a very small number of cases of restricted utility (like ($$) prototyped functions used with sort), they don't do what you want (unless you're very weirdo to match the craziness of Perl prototype semantics).

One example:

sub foo ($$) { $_[0] + $_[1] } # add two scalar args :)

foo(1,2) 
@a = (1,2); foo(@a); # death !! not enough arguments
@b1 = (2); @b2 = (3); foo(@b1,@b2) # 2 !?!?  = scalar @b1 + scalar @b2
[download]

And don't take my words. Tom Christiansen said that a long time ago and Damian Conway said more about it in "Perl Best Practices".

That said, maybe you may get the behavior you want with a module like Params::Validate. See the docs with a special attention to the section on "Callback Validation":

This particular form of prototype provides a facility that cannot be achieved any other way. Perhaps you should understand what that facility is before handing out old and well worn advice those who already know it.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

"Too many [] have been sedated by an oppressive environment of political correctness and risk aversion."

You could always roll your own at run-time, something like (untested):

our %proto = ( '@\@' => sub { return !grep (ref( $_ ) ne 'ARRAY' ), @_
+; },
               # ...
               # proto => sub { enforcement-code }
);

sub foo {
    $proto{ '@\@' }{@_} or die;
    # followed by "real" code for sub foo
}
[download]

( PS. Yes, I surely can sub ttt(@); ttt(\@a,\@b,\@c) but it is not at all as interesting as ttt(@a,@b,@c) )

Nor is it the same thing. The main reason that you should be considering the second option would be if you needed to pass the value of the arrays such that they would not potentially be modified by the subroutine you are calling. If you are not so worried about that possibility and more worried about potentially copying large data structures, the former is your best option.

Unfortunately, I can't offer any useful advice on the question at hand :)

perl -e 'split//,q{john hurl, pest caretaker}and(map{print @_[$_]}(joi
+n(q{},map{sprintf(qq{%010u},$_)}(2**2*307*4993,5*101*641*5261,7*59*79
+*36997,13*17*71*45131,3**2*67*89*167*181))=~/\d{2}/g));'
[download]

A prototype of (@) is meaningless. It does not force anything because the smallest list is empty: it asks for an argument in list context, not an array.
I don't think there is a prototype for what you ask, you will probably have to do without (ttt(\@a,\@b,\@c)) and use ref to check that each argument is of the correct type. Trouble is that this is a run-time check not a compile-time check as you get with a prototype.

Basically, I need something like sub ttt(\@;\@...) where ... is ellipsis, so one or more arrays can be passed by reference.

Why?