This will lock out the possibility of using techniques like closures though...

Why don't you just break out each sub into a separate file. Then, you just

[update: argh, I just read your requirements more closely. Still I think you can slot it right in. As soon as you call &{$screen{$screen}} you'll hit the AUTOLOAD which will proceed as before but instead you'll want to do the file, and assign the results to $screen{$screen}} before executing the sub]

Then, all you would have to do is to define your AUTOLOAD to requires the desired file, which could be named something like main.screen (long live self-documenting file names), which defines main_screen... and then run that.

This would bring in the code on demand. If you changed the code in main.screen however, you would have to stop the program and restart it. If this is a problem, you could then start to get fancy, using anonymous subs, and reload the code on the fly if you notice that the file modification time has changed. I have written a Net::IRC bot that does this kind of trickery. I can add new code functionality to the bot whilst it is connected to a channel. The necessary smarts to handle keeping track of files is abstracted into a package.

Well, if you insist on using SelfLoader, then I'd make the subroutine names the same as the screen names and replace the hash with just an array of screen names (then you could build the hash to preserve the current calling scheme if you like:

foreach my $screen (  @screens  ) {
    no strict 'refs';
    $screens{$screen}= \&$screen;
}
[download]

You could look into whether, when using AutoLoader, if you could get your modules Makefile to call AutoSplit in such a way that you end up with a list of subroutines in the installed module so you don't have to add new screen names in two places.

It would be easier to make auto- or self-loading if you could make a class called Screens, then create a method called main, a method called foo, etc. Then you could move them down after __DATA__, and could therefore use the SelfLoader or AutoLoader. See perlman:perltoot for how to do this.

Once you'd changed to OO syntax, your way of calling this functionality could be:

my $screen_maker = ScreenMaker->new();
$screen_maker->$current_screen();
[download]

For backwards compatibility, your &screens function could write stub routines to access the screens, like so:

use ScreenMaker;
use Carp qw(carp);

sub screens {
    carp "Using deprecated '&screens' function";
    my $screen_maker = ScreenMaker->new();
    %screens = (
        main => sub { $screen_maker->main() },
        foo -> sub { $screen_maker->foo() },
    };
}
[download]

That way, currently-running code will still work, but will generate warnings that allow you to transform to OO methods.

stephen