Any ideas on how I can avoid 4000 lines of many module subs in one source file?

Rethink your design. Are there logical boundaries where you could subdivide your large module into smaller pieces?

You should follow chromatic's advice: rethink your design.

But in the meantime, check 'package' and 'do' for some side effects of using non-modules to include code.

While I agree that if you're going to break code into pieces it should be in response to some requirement of the code itself, I sympathise with the too-much-$@%! problem. Perhaps you could try:

a different text editor
This is a navigation problem, not a structure problem. Use an editor with better navigation features: syntax colouring, code folding, jump-to-method, position markers and good search tools will all help.

more POD
I find that well (and consistently) documented code is much easier to get around, especially if it has become unfamiliar. Consider spreading the docs throughout the module, rather than storing them at the end, and adopt a consistent structure to give easy visual cues when hunting for the right line.

question your premises
Why does it have to occupy a single namespace? That suggests a lot of globals or $package::variables, which will very likely have to be rooted out later for one reason or another. Refactor the requirement away.

seek help
Do you really need 4000 lines of code? Sifting carefully through CPAN could cut it down considerably and make it more readable too. Except I'm sure you did that already. And if all else fails:

use mixin;
mixins will let you separate code along whatever lines you like while preserving a single namespace. Schwern's adamantly lower-case module is very easy to use:

Package My::Enormous::Package;
use mixin 'My::Filingorsomething';

Package My::Filingorsomething
use mixin::with 'My::Enormous::Package';
[download]

Hope there's something useful in there. Please excuse if labouring obvious.

Um ... put package Mod; at the top of each of Mod-part1.pm and Mod-part2.pm?

The package statement doesn't propagate beyond file boundaries so you need to be explicit in your individual files

Update: Sorry, I didn't see what you had written about use base (that's what I get for skimming rather than reading). Hmm. You can always declare your subs like this:

sub Mod::foo { ... }
[download]

And if variables are a problem too, then you would add

use vars qw($Mod::var1 $Mod::var2  @Mod::var3  %Mod::etc);
[download]

at an appropriate place. Note that this still won't make __PACKAGE__ have the value of Mod

Why are you using __PACKAGE__ anyway? Do you need to? As chromatic said, perhaps you need to re-think your design.

Also, you can always redeclare everything at the top of each module part:

# Mod-part1.pm
package Mod;
use base qw(Meta);
...
# Mod-part2.pm
package Mod;
use base qw(Meta);
...
[download]

(I was only using __PACKAGE__ to see why things weren't being put in the right namespace.)

The sub Mod::foo { } suggestion was a new thought, but like __PACKAGE__, the magic identifier SUPER was not correct. I would rather use SUPER than hardwire the base class, but it's pretty arbitrary.

As for the many suggestions to rethink the design; yes, it's a good idea to rethink it. However, I've rethought, and in my particular case, it rightfully should be one class with a few semi-distinct duties that are not easy to aggregate or embed or delegate. I'm working near the base of a large class hierarchy, and the base classes really must cover their core duties.

--
[ e d @ h a l l e y . c c ]

Then I would think that restating the package and base class (and whatever else you need) at the start of each module part is your best bet.

duff

$ cat tt.pl 
sub foo { print "bar\n" }
$ cat ttmain.pl
package x;
eval `cat tt.pl`;
x::foo();
$ perl ttmain.pl 
bar
[download]

If I reassert the package name at the beginning of a part file, it loses all of the other common preparatory code like use base or other modules.

Any ideas on how I can avoid 4000 lines of many module subs in one source file?

I know Perl doesn't have an #include directive.

Sure it does. the -P flag to perl runs the code through cpp first. Here's a quick example:

#!/usr/bin/perl -Pw
use strict;

#define CHOICE 1

print "Hey look! I'm",

#ifndef CHOICE
' not',
#endif

" using the C preprocessor.\n";

# Here is an example of #include.

my $passwd = <<'-PASSWD-';

#include "/etc/passwd"

-PASSWD-

print "Here is /etc/passwd: $passwd\n";
[download]

note -P can have problems distinguishing between preprocessor directives and perl comments. Also I don't know how well it works on non-Unix platforms where cpp might be missing. All in all it's a poor solution to your problem but it's there if you do need to us it.