Perl: símbolos de exportación de módulo que tiene> 1 paquete

Question

módulo foo/bar.pm

package foo::bar; 
stuff 
stuff 
package foo::wizzy; 
require Exporter; 
our @ISA=qw(Exporter); 
our @EXPORT=qw(x); 
use constant 
{ 
    x=>1 
}; 

un consumidor que hace

use Foo::bar; 

no recibe la exportación foo::wizzy::x

sé Puedo convertirlo en dos módulos separados, pero aún así debería poder hacer que esto funcione, ¿no es así?

Answer 1

Al final del módulo, puso:

BEGIN { $INC{'foo/wizzy.pm'} = 1 } 

Luego código puede simplemente decir:

use foo::bar; 
use foo::wizzy; 

para obtener las exportaciones de foo :: wizzy.

Answer 2

Cuando se llama a use foo::bar, lo que realmente sucede es esencialmente:

BEGIN { 
    require foo::bar; 
    foo::bar->import; 
} 

(ver perldoc -f use)

Así import nunca está recibiendo llamadas en foo::wizzy. Si también desea importar esos símbolos, puede llamar al BEGIN { foo::wizzy->import } usted mismo (después de use foo::bar). O, como dijiste, simplemente divide estos dos paquetes en archivos separados, que serían mucho más legibles para los humanos.

(Por cierto, no es aconsejable el uso de nombres de paquetes entubados inferior, como los que son generalmente reservados para prágmata Perl.)

Answer 3

Puede hacerlo utilizando el método del exportador export_to_level tener el "paquete principal" re -export símbolos del "otro" paquete de este modo:

sub import { 
    my $self = shift; 
    $self->export_to_level(1, @_); 
    Some::Other::Module->export_to_level(1); 
} 

aunque si Some::Other::Module hace algo más complicado que "exportar todo" es probable que necesite un manejo más elegante para @_.

que realmente tiene que preguntarse por qué , aunque — No me puedo imaginar un uso para esto que es compatible con las palabras "bueno" :) código

Answer 4

En primer lugar, me parece útil el uso de llaves encerrando para controlar el alcance cuando se incluyen múltiples paquetes en un archivo. Además, adjuntar el paquete en un bloque BEGIN hace que funcione más como si se usara un use adecuado para cargarlo, pero esto es principalmente si estoy introduciendo el paquete en el script principal.

use Foo es lo mismo que BEGIN { require Foo; Foo->import }.

lo tanto, usted tiene dos opciones:

• llamada BEGIN{ Foo::Whizzy->import; } en el script principal.
• make Foo::Bar::import disparador Foo::Whizzy::import en el módulo de llamada.

En Foo/Bar.pm:

{ package Foo::Bar; 
    use Exporter qw(export_to_level); 

    # Special custom import. Not needed if you call Foo::Whizzy->import 
    sub import { 
    shift; 
    export_to_level('Foo::Whizzy', 1, @_); 
    } 

    # stuff 
    # stuff 
} 

{ package Foo::Whizzy; 
    require Exporter; 

    our @ISA=qw(Exporter); 
    our @EXPORT=qw(x); 
    use constant { x=>1 }; 

} 

1; # return true 

En su código principal:

use Foo::Bar; 

# If you don't do a custom import for Foo::Bar, add this line: 
BEGIN { Foo::Whizzy->import };