#!/usr/bin/perl

my $saludos = "No importa donde: Saludos de ";

# Namespace 'Mama'
package Mama;
$edad = 50;
print 'En namespace '.__PACKAGE__.', $edad = ', $edad, "\n";
print $saludos,__PACKAGE__,"\n";
	  
# Namespace 'Papa'
package Papa;
$edad = 55;
print 'En namespace '.__PACKAGE__.', $edad = ', $edad, "\n";
print $saludos,__PACKAGE__,"\n";

# Namespace 'main' (default namespace)
package main;
$edad = 25;
print 'En namespace '.__PACKAGE__.', $edad = ', $edad, "\n";
print 'Mi edad publica: ', $main::edad, "\n";
print 'La edad de mi Mama: ', $Mama::edad, "\n";
print 'La edad de mi Papa: ', $Papa::edad, "\n";
print $saludos,__PACKAGE__,"\n";

# Namespace 'Mama'
package Mama;
$edad = 50;
my $secret = 'secreto de mama';
1;

# Namespace 'Papa'
package Papa;
$edad = 55;
my $secret = 'secreto de papa';
1;

#!/usr/bin/perl
use strict;
use Mama;
use Papa;
my $edad = 25;
print 'Mi edad: ', $edad, "\n";
print 'La edad de mi Mama: ', $Mama::edad, "\n";
print 'La edad de mi Papa: ', $Papa::edad, "\n";
print "Mis papas tienen secretos declarados con 'my':\n";
print '$Mama::secreto no es accesible desde aca', "\n";
print '$Papa::secreto tampoco', "\n";

# Trim.pm
package Trim;
sub ltrim {
    $string = shift;
    $string =~ s/^\s*//g;
    return $string;
}
sub rtrim {
    $string = shift;
    $string =~ s/\s*$//g;
    return $string;
}
sub trim {
    $string = shift;
    $string =~ s/^\s*(\S+)\s*$/$1/g;
    return $string;
}
1;

#!/usr/bin/perl
use Trim;
my $s = '  hola ';
my $s2 = Trim::trim($s);
my $s3 = Trim::ltrim($s);
my $s4 = Trim::rtrim($s);
print "$s\n";
print "$s2\n";
print "$s3\n";
print "$s4\n";

1. package SP::Tools;
2. use strict;
3. use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);
4. use Exporter;
5. @ISA = qw(Exporter);
6. @EXPORT = qw(trim);
7. @EXPORT_OK = qw(ltrim rtrim);
8. $VERSION = 1.00;

sub ltrim {...}
sub rtrim {...}
sub trim {...} 

1. package SP::Tools;
   El nombre SP::Tools se refiere al archivo SP/Tools.pm, que es el path donde Perl busca por el módulo al ejecutar use.
   Perl no busca todo el disco por el módulo, sólo en los paths que están definidos en el arreglo global de Perl @INC, entre ellos /usr/local/lib/perl5/site_perl/5.005 y /usr/libdata/perl/5.00503.
   El path actual (.) siempre está definido en @INC, así el programa en el ejemplo arriba programa2.pl encuentra al módulo Trim.pm, por que los dos están en el directorio actual.
   En el caso de SP::Tools hay que crear un subdirectorio SP donde se coloca Tools.pm.
   Sin embargo, si se ejecuta el programa desde /otro/directorio, busca por SP/Tools.pmen el path actual (.) que corresponde a /otro/directorio/SP/Tools.pm (que no existe), así el programa falla.
   Módulos de CPAN siempre se instalan en uno de los directorios /usr/local/lib/perl5/site_perl/5.005 y /usr/libdata/perl/5.00503, paths absolutos incluidos en @INC, así programas que usan módulos de CPAN los encuentran independente del path actual.
2. use strict;
strict no es un módulo, sino un llamado pragma (compiler directives), siempre se debe usar por seguridad y facilidad de hacer debug, leer más en en perldoc strict
3. use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);
   Cuando se usa use strict normalmente no se permite el uso de variables globales (que normalmente nunca se debe usar como programador profesional). Sin embargo, en este caso queremos combinar un módulo seguro y facil de hacer debug (use strict;) pero necesitamos exportar ciertos variables (hacerlos globales) para que sean accesibles desde fuera del módulo, o sea desde nuestros programas.
   El use strict; nos permite hacer esto siempre y cuando declaramos explicitamente que variables vamos a exportar (hacer globales).
   
4. use Exporter;
   Cuando un programa ejecuta use SP::Tools trata de importar las variables públicas usando el método SP::Tools->import().
   Nuestro SP::Tools no incluye tal método import, pero lo importamos del módulo Exporter.
   Leer más en perldoc Exporter.
5. @ISA = qw(Exporter);
   Se lee esta linea como: Is a Exporter.
   Cuando un programa usa SP::Tools no encuentra el método import en SP::Tools, revisa el arreglo estandar de Perl @ISA, donde encuentra que debe buscar en Exporter para encontrar tal método.
   Para que el programa pueda revisar @ISA, hay que exportarlo como hicimos con use vars.
   En otras palabras, esta es una forma de heredar métodos de otros módulos.
6. @EXPORT = qw(trim);
   Cuando un programa ejecuta use SP::Tools; todos los métodos listados en @EXPORT se importa por default, así se puede accesar la funcíon trim en vez de SP::Tools::trim.
   La lista de métodos exportados por default se debe usar con moderación, como el nombre de un método en este módulo puede causar conflicto con un método de otro módulo, cuando un programa usa dos o más módulos.
7. @EXPORT_OK = qw(ltrim rtrim);
   Los métodos listados en @EXPORT_OK no se exportan al programa por default, pero como dice el nombre, es OK a exportarlos si así se especifica en el programa así.
   Estos metodos se importan al programa con use SP::Tools qw(ltrim);.
   
8. $VERSION = 1.00;
   Con $VERSION se especifica la versión de este módulo.
   Como con cualquier software, una versión nueva contiene más funciones que la anterior, o correcciones de bugs en funciones existentes.
   Si por ejemplo una versión anterior de un módulo ($VERSION = 0.666) contenía un bug grave que formatea el disco duro bajo ciertas circunstancias, pero en las versiones más recientes ($VERSION = 1.00, $VERSION = 1.01) esto está arreglado, un programa puede asegurarse que está usando la versión 1.00 o mayor con use SP::Tools 1.00;.
   Si $VERSION es igual o mayor que 1.00 el programa se ejcuta como normal, si es menor que 1.00 el programa termina con un mensaje de error:

   SP::Tools version 1 required--
   this is only version 0.666 at programa3.pl line 3.
   BEGIN failed--compilation aborted at programa3.pl line 3.
   

   Nota: Se puede combinar $VERSION con los métodos en @EXPORT_OK:
   use SP::Tools 1.00 qw(ltrim);

# SP/Tools.pm
package SP::Tools;
use strict;
use vars qw(@ISA @EXPORT @EXPORT_OK $VERSION);
use Exporter;
@ISA = qw(Exporter);
@EXPORT = qw(trim);
@EXPORT_OK = qw(ltrim rtrim);
$VERSION = 1.00;
sub ltrim {
    my $string = shift;
    $string =~ s/^\s*//g;
    return $string;
}
sub rtrim {
    my $string = shift;
    $string =~ s/\s*$//g;
    return $string;
}
sub trim {
    my $string = shift;
    $string =~ s/^\s*(\S+)\s*$/$1/g;
    return $string;
}
1;

#!/usr/bin/perl
use strict;
use SP::Tools;
my $s = '  hola ';
my $s2 = trim($s);
print "$s\n";
print "$s2\n";

#!/usr/bin/perl
use strict;
use SP::Tools 1.00 qw(ltrim);
my $s = '  hola ';
my $s2 = ltrim($s);
print "$s\n";
print "$s2\n";

#!/usr/bin/perl -w
use strict;
use lib qw(/my/path/to/modules);
use WWW::Search::Google;
# Aqui va el codigo...	  

# Crear el subdirectorio SP/Tools del directorio actual,
# y todas las plantillas
h2xs -XA -n SP::Tools
# Cambiar al directorio creado
cd SP/Tools/
# Insertar el código ya hecho y escribir la documentación,
# todo en Tools.pm
# Agregar código de prueba a test.pl
perl Makefile.PL
# Crear el archivo SP-Tools-0.01.tar.gz
# (si no cambiaste $VERSION)
make dist
# Listo para distribuición!