misterioso * davanti al sub nidificato

Question

Qual è l'esatta funzione/scopo di * di fronte a _fact e come può essere scritto in modo equivalente?

sub fact { 
    my ($n) = @_; 

    local *_fact = sub { 
     my ($n, $prod) = @_; 
     return $prod if $n == 0; 
     return _fact($n-1, $n*$prod); 
    }; 

    return _fact($n, 1); 
} 

fact($n); 

Answer 1

check typeglob aliases

esempio di cui sopra dovrebbe essere scritto utilizzando anonima subroutine/chiusura:

sub fact { 
    my ($n) = @_; 

    my $_fact; 
    $_fact = sub { 
     my ($n, $prod) = @_; 
     return $prod if $n == 0; 
     return __SUB__->($n-1, $n*$prod); 
    }; 

    return $_fact->($n, 1); 
} 

Answer 2

E 'così chiamato typeglob e viene utilizzato per creare alias di tabella. Vedi perldoc reference per maggiori informazioni.

Answer 3

Sembra che questo sia un tentativo funky di creare una chiusura assegnando un riferimento al codice typeglob denominato _fact e quindi chiamandolo pseudo-ricorsivo. (nota: un typeglob è il contenitore per tutte le variabili con un nome particolare).

Un modo pressoché equivalente (e molto altro standard) per scrivere questo sarebbe:

sub fact { 
    my ($n) = @_; 

    my $_fact; 

    $fact = sub { .... }; # Assigning code-ref to scalar variable. 

    return $_fact->($n, 1); # Note the arrow syntax to deref the code-ref 
} 

... ma, come è stato gentilmente segnalato, che ha una perdita di memoria in esso ... così, io dico solo la chiusura discarica del tutto e scrivere in questo modo:

sub fact { 
    my($n,$prod) = @_; 

    return((defined $prod) ? (($n == 0) ? $prod : fact($n-1, $n * $prod)) : fact($n,1)); 
} 

(ricordate, l'unica cosa peggiore di ricorsione infinita è ... infinito ricorsione)

Answer 4

Idealmente, l'autore della funzione avrebbe voluto utilizzare

sub fact { 
    my ($n) = @_; 

    my $_fact; $_fact = sub { 
     my ($n, $prod) = @_; 
     return $prod if $n == 0; 
     return $_fact->($n-1, $n*$prod); 
    }; 

    return $_fact->($n, 1); 
} 

Purtroppo, che ha una perdita di memoria. Il sotto sub ha un riferimento a $_fact, che contiene un riferimento al sub anonimo. $_fact dovrebbe essere cancellato per interrompere il riferimento all'uscita.

sub fact { 
    my ($n) = @_; 

    my $_fact; 
    $_fact = sub { 
     my ($n, $prod) = @_; 
     return $prod if $n == 0; 
     return $_fact->($n-1, $n*$prod); 
    }; 

    my $rv; 
    my $e = eval { $rv = $_fact->($n, 1); 1 } ? undef : ($@ || 'Unknown'); 
    $_fact = undef; 
    die $e if $e 
    return $rv;  
} 

Ma questo è BRUTTO! Un modo per evitare il problema è l'utilizzo di Y combinator. Un modo molto più semplice per evitare il problema è quello di memorizzare il codice di riferimento in una variabile del pacchetto invece di una variabile lessicale (poiché solo le variabili lessicali sono catturate dai sottotitoli). Questo è ciò che fa il codice che hai postato. Tenete a mente che

*_fact = sub { ... }; 

è fondamentalmente una versione di runtime di

sub _fact { ... } 

Sia assegnare il sub a fessura CODICE del simbolo _fact.

Detto questo, 5.16 ha introdotto una correzione migliore:

use feature qw(current_sub); 

sub fact { 
    my ($n) = @_; 

    my $_fact = sub { 
     my ($n, $prod) = @_; 
     return $prod if $n == 0; 
     return __SUB__->($n-1, $n*$prod); 
    }; 

    return $_fact->($n, 1); 
}