Newsgroup: it.comp.lang.perl
Titolo: "Coping with Scoping", traduzione online

Salve.
Mi e` capitato di citare qualche volta un articolo di
Mark-Jason Dominus, "Coping with Scoping", come lettura
consigliata. Ora e` disponibile una traduzione italiana
del documento: la trovate nella sezione documenti di
www.perl.it
:
 
http://www.perl.it/documenti/articoli/namespaces/index.html
Rinnovo il consiglio di leggere l'articolo: e` abbastanza
breve ma denso di contenuti.
ciao,
S.

    
http://www.perl.it/documenti/articoli/namespaces/index.html
Mi sembra un ottima traduzione. Bravo/i.
-- 
                         Maurizio - Tannoiser - Lemmo
                 Founder Member of ERLUG 
http://erlug.linux.it
-------------------------------------------------------------------------------
If God had meant us to compute securely, He'd have given us more prime numbers!

Stefano Rodighiero ha scritto:

Grazie per il lavoro fatto. L'articolo è chiaro e fondamentale per la
comprensione di uno dei meccanismi più affascinanti del Perl.
A parte ciò vorrei aggiungere qualcosa a integrazione e porre un quesito.
Come è noto una variabile lessicale (o variabile my) è visibile all'interno
del blocco e *dei blocchi in esso contenuti*, quindi se io scrivo:
-----------------------
#!/usr/bin/perl
use strict;
Ciao();
sub Ciao {
        my $testo = "Ciao\n";
        PrintCiao();
        sub PrintCiao {
                print "Testo: $testo";
        } 
}
-----------------------
ottengo la mia bella scritta:
Testo: Ciao
però se io impongo il flag di warning -w
allora la risposta sarà:
Variable "$testo" will not stay shared at 
var_sub.pl
 line 11.
Testo: Ciao
L'unico modo per evitare il warning è scrivere il codice in questa forma:
------------------------------
#!/usr/bin/perl -w
use strict;
Ciao();
sub Ciao {
        my $testo = "Ciao\n";
        my $PrintCiao = sub {
                print "Testo: $testo";
        }; 
        &$PrintCiao();
}
------------------------------
Quindi devo referenziare una subroutine anonima e "dichiararla" prima della
chiamata tramite reference.
Chiedo:
1) a parte l'eleganza il warning è accettabile, o prelude a problemi?
2) ci sono dei vantaggi di altro tipo a seguire la strada della subroutine
anonima?
Grazie.
-- 
-- Marco Allegretti --
http://www.shishii.com

 -----------------------
Benche` l'interprete consenta di scrivere la definizione di una subroutine
all'interno di un'altra subroutine, in Perl non esiste il concetto di
subroutine dotata di nome e con scope lessicale (ci sara` in Perl 6, ma
"I will not utter here" :)).
Nel codice che porti come esempio non ci sono problemi, ma prova con questo:
     #!/usr/bin/perl
     use strict;
     use warnings;
     use Devel::Peek;
     esterna( "Prima chiamata\n" );
     esterna( "Seconda chiamata\n" );
     interna();
     sub esterna
     {
         my $x = shift;
         Dump( $x );
         interna();
         sub interna
         {
             Dump( $x );
             print $x;
         }
     }
Guardando l'output di Devel::Peek::Dump() ti accorgerai che la sub interna()
conserva il valore della variabile lessicale $x creata al momento della
*prima chiamata* alla sub esterna(), e conserva tale valore anche
durante le successive chiamate. Infischiandosene quindi di quello che viene
passato ad esterna() alle chiamate successive. Le due sub quindi non
condividono la stessa variabile. Schematicamente questo e` quello che
avviene:
   Prima chiamata a esterna()
     Creazione del lexical $x (il suo valore e` "Prima chiamata").
     La definizione di interna() ha effetto: la nuova sub viene
      installata nella tabella dei simboli.
     Chiamata a interna(). Viene stampato il valoreo "Prima chiamata".
     Uscita da esterna(). Poiche` interna() esiste ancora (e` un
      simblo globale) e contiene un riferimento a $x, tale variabile
      lessicale non viene cancellata, e verra` ricordata d'ora in
      avanti dalla sub interna().
   Seconda chiamata a esterna()
     Creazione di un altro lexical $x (il suo valore e` "Seconda chiamata").
     Chiamata a interna() (la sub esiste gia` nella tabella dei simboli,
      non viene ri-creata).
     Stampa del valore di $x "conosciuto" da interna(), che e` ancora
      quello di prima -> "Prima chiamata".
Scrivere la definizione di una sub con nome all'interno del blocco che
definisce un'altra sub e` fuorviante, poiche` in realta` tra le due non
c'e` una stretta parentela. La necessita` di usare un riferimento ad una
sub anonima c'e` perche` in questo caso si realizza una chiusura, cioe`
un "pacchetto" di subroutine piu` ambiente al momento della sua definizione.
In questo modo ogni volta che chiami la chiusura e` come essa fosse stata
chiamata nel contesto in cui e` stata definita originariamente.
ciao,
S.

 originariamente.
Perdonami... il resto è tutto chiaro, ma quanto riportato sopra non lo
capisco, potresti spiegarmi meglio?
