No - that's really helpful - the idea that I can just work within the namespace of the original module in my other script/module, by doin',

 

{

package Module; 

# Yadda Yadda, 

}
[download]

 
package Module; 


package main; 
# And now back to our main script...
[download]

would this do the same thing:

If you had been in main initially, yes.

Speaking of similar things, I didn't answer an earlier question.

sub Foo::Bar::f {}
[download]

is very similar to

{
   package Foo::Bar;
   sub f {}
}
[download]

But the code is compiled in a different package. This affects caller and other things:

use strict;
use warnings;

sub Foo::f {
   our $var;
   print(__PACKAGE__, "\n");
   print("$var\n");
}

{
   package Bar;
   sub f {
      our $var;
      print(__PACKAGE__, "\n");
      print("$var\n");
   }
}

$main::var = 'main!';
$Foo::var = 'foo!';
$Bar::var = 'bar!';

Foo::f();
# main
# main!

Bar::f();
# Bar
# bar!
[download]

I'm guessing the braces localize what I'm doing, so once outside them, I can do whatever I want.

Be careful. The braces ({}) don't localize everything you are doing. The create a scope for your variables, but your package and subroutine declarations remain global. I think the form you used above gives a misleading impression that the package is block scoped.

Update 2: Thanks for the heaping helping of crow, ikegami--I needed it. I was wrong. Dead wrong. See package. I read this wrong information somewhere, failed to check it, and have promulgated bogus information as a result.

{   package Foo;
    # Foo stuff
    # goes in here.
}
sub FooFunc {
    # This function is Foo::FooFunc!
    #actually it's not!  It is in main.  I was wrong.
}

package main;
sub MainFunc {
    # This function is main::MainFunc.
}
[download]

That's the reason why I like this approach better:

package Foo;
{    # Foo stuff
     # goes in here.
}


package main;

# back in main.
[download]

Update: After looking at the module, I'd be inclined to use ikegami's suggestion for using a localized override.

This will minimize the spooky action at a distance factor.

#!/usr/bin/perl
use strict;
use warnings;

package Foo;

sub method {
    routine();
}

sub routine {
    return __PACKAGE__;
}


package Foo::Bar;
our @ISA = qw( Foo );

sub routine {
    return __PACKAGE__;
}

sub method {
    no warnings 'redefine';
 
    # Temporarily override routine() in the parent class.
    local *Foo::routine = \&routine;
    
    # Delegate to parent method.
    my $self = shift;
    $self->SUPER::method(@_);
}

package main;
print "Foo:      ", Foo->method, "\n";
print "Foo::Bar: ", Foo::Bar->method, "\n";
print "Foo:      ", Foo->method, "\n";
[download]


TGI says moo

Be careful. The braces ({}) don't localize everything you are doing. The create a scope for your variables, but your package and subroutine declarations remain global.

No, that's wrong. package is lexically scoped. That's why you don't have to switch it back after a module changes it.

print(__PACKAGE__, "\n");
{
   package Foo;
   print(__PACKAGE__, "\n");
}
print(__PACKAGE__, "\n");
[download]

main
Foo
main
[download]

It's really just a nit, but you're leaking an alias to @Foo::Bar::ISA. I also use BEGIN {} instead of {} inlined modules. I'd write your program as:

#!/usr/bin/perl
use strict;
use warnings;

BEGIN {
   package Foo;

   sub method {
       routine();
   }

   sub routine {
       return __PACKAGE__;
   }
}

BEGIN {
   package Foo::Bar;
   our @ISA = qw( Foo );

   sub routine {
       return __PACKAGE__;
   }

   sub method {
       no warnings 'redefine';
 
       # Temporarily override routine() in the parent class.
       local *Foo::routine = \&routine;
    
       # Delegate to parent method.
       my $self = shift;
       $self->SUPER::method(@_);
   }
}

print "Foo:      ", Foo->method, "\n";
print "Foo::Bar: ", Foo::Bar->method, "\n";
print "Foo:      ", Foo->method, "\n";
[download]