Che cosa significa la funzione "sottofunzione ($$)"?

Question

Sono stato con Perl per qualche tempo, ma oggi mi sono imbattuto in questo codice:

sub function1($$) 
{ 
    //snip 
} 

Cosa significa questo in Perl?

Answer 1

È una funzione con un prototype che accetta due argomenti scalari.

Ci sono forti argomenti per non utilizzare in realtà i prototipi Perl in generale - come indicato nei commenti seguenti. L'argomento più forte è probabilmente:

• Far More Than Everything You've Ever Wanted to Know about Prototypes in Perl

C'è una discussione su StackOverflow dal 2008:

• SO 297034

C'è una possibile sostituzione nel modulo MooseX::Method::Signatures.

Answer 2

Come l'altra risposta menziona, lo $$ dichiara un prototipo. Ciò che l'altra risposta non dice è a cosa servono i prototipi. Non sono per la convalida dell'input, sono suggerimenti per il parser.

Immaginate di avere due funzioni dichiarato come:

sub foo($) { ... } 
sub bar($$) { ... } 

Ora, quando si scrive qualcosa di ambiguo, come:

foo bar 1, 2 

Perl sa dove mettere le parentesi; la barra richiede due arg, quindi consuma i due più vicini. foo prende uno arg, così prende il risultato di bar e due args:

foo(bar(1,2)) 

altro esempio:

bar foo 2, 3 

Lo stesso dicasi; foo prende uno arg, quindi diventa il 2. bar prende due argomenti, quindi diventa foo(2) e 3:

bar(foo(2),3) 

Questa è una parte abbastanza importante di Perl, in modo che respinge come "non usare mai" si sta facendo un cattivo servizio. Quasi tutte le funzioni interne utilizzano i prototipi, quindi comprendendo come funzionano nel proprio codice, è possibile ottenere una migliore comprensione di come vengono utilizzati dai builtin. Quindi puoi evitare parentesi non necessarie, il che rende il codice più gradevole.

Infine, un anti-modello vi guardia contro:

package Class; 
sub new ($$) { bless $_[1] } 
sub method ($) { $_[0]->{whatever} } 

Quando si sta chiamando codice come metodi (Class->method o $instance->method), il controllo di prototipo è completamente priva di senso. Se il tuo codice può essere chiamato solo come metodo, aggiungere un prototipo è sbagliato. Ho visto alcuni moduli popolari che fanno questo (ciao, XML::Compile), ma è sbagliato, quindi non farlo.Se si desidera documentare quanti args passare, come su:

sub foo { 
    my ($self, $a, $b) = @_; # $a and $b are the bars to fooify 
    .... 

o

use MooseX::Method::Signatures; 

method foo(Bar $a, Bar $b) { # fooify the bars 
    .... 

differenza foo($$), questi sono significativo e leggibile.