This is a common problem with parrallel class heirarchies, and one which no one has managed to solve well. It is sometimes referred to as the "Expression Problem", here is a paper which describes how it is solved in Scala using Traits. However, I don't think this particular solution would be possible using Moose.

The Moose-ish solution would be as follows:

package EvanCarroll::Quiz;
use Moose;

has 'question_class' => (is => 'ro', default => 'EvalCarroll::Question
+');

sub new_question {
  my $self = shift;
  my $question = $self->question_class->new(@_);

  push @{ $self->questions }, $question;

  $question;
}
[download]

my $quiz = EvanCarroll::Quiz->new(
    question_class => 'My::Custom::Question'
);
[download]

Of course you can also do the same in QuizMaster with the Quiz class, and get that to be dynamic as well.

Now if you want to allow the author of a custom Quiz subclass to supply an arbitrary Question class, and not enforce namespace consistency across Quiz and Question, then your user could just do this:

package Stvn::Quiz;
use Moose;
extends 'EvalCarroll::Quiz';

has '+question_class' => (default => 'Some::Random::Question');
[download]

And of course, this does not prevent your Quiz::Master class from still forcing the question_class parameter in the Quiz constructor (as shown above). Instead it only creates a new default for the new Quiz subclass.

Hope this helps.

Firstly, this is an awesome suggestion.


How would suggest how to load these though, eval "require $self->question_class;"; before my $question = $self->question_class->new(@_); or is there a better way to do this too?


Evan Carroll
www.EvanCarroll.com

... is there a better way to do this too?

Not really, UNIVERSAL::require is nice, but it pollutes UNIVERSAL, which is bad. Inside Moose we actually do this:

my $file = $class . '.pm';
$file =~ s{::}{/}g;
eval { CORE::require($file) };
confess("Could not load module '$class' because : $@") if $@;
[download]

whenever we need to load a class. But aside from that I don't have a better suggestion.
-stvn

First, never say new SomeClass in OO code. You can usually get away with it when writing non-OO code that merely uses OO code but you're really asking for trouble when you do it in an OO module. The problem is that if you say new Whatever in some class like Question you mean Whatever->new but if your local Question->new is already defined by the time you write the above line then you really get Question->new instead. It's 100% a bug on your part and you should never do this.

Secondly, use Ovid's aliased module to get short names. Recommend it to your users. Then they can have short names too without any extreme hacks to ISA.

use aliased 'NHB::QuizMaster::Custom::NHMCCD::Quiz';
use aliased 'NHB::QuizMaster::Custom::NHMCCD::Question';
use aliased 'NHB::QuizMaster::Custom::NHMCCD::Answer';

# Now use the Quiz->, Answer->, Question-> namespaces.
[download]

The alias deal doesn't seem to be an apt suggestion for a few reasons,
1. It would require me to subclass all three packages, rather than just the select ones I wanted to subclass
2. Even if I wanted to subclass the three modules, unless subclass exported and poluted the namespace of every other package (superclass), it would seem as if I would have to have totally redundant code
So now in the subclass, I would have something like

##Non redundant code
use aliased 'NHB::QuizMaster::Custom::NHMCCD::Question';

##Totally redundant code
sub new_question {
  my $self = shift;
  my $question = new Question( @_ ); Question->new(@_);

  push @{ $self->questions }, $question;

  $question;
}

I'm guessing that the alias doesn't affect the superclass



Evan Carroll
www.EvanCarroll.com

You said "new Question" which you already know is ass. Don't be an idiot, don't do that.

aliased isn't a structural thing - it means you don't have to use long class names in your code. It doesn't solve any subclassing or other interface problems. I suggested that you trash your entire idea to do @ISA evil and get to nirvana through syntactic sugar.

⠤⠤ ⠙⠊⠕⠞⠁⠇⠑⠧⠊

Its a bit icky, but you could put 'make_question' into your base Quiz class, munge the type name and do something like this:

package NHB::QuizMaster::Quiz;

sub make_question
{
  my $s = shift;
  my $type = ref $s; # X::Y::Z::Quiz
  $type =~ s/::Quiz$/::Question/;
  my $question = new $type;
  ...etc
}
[download]

It also feels a bit icky, but maybe that's just me.

sub new_question {
    my $self = shift;

    my $class = ref $self;
    ( my $question_class = $class ) =~ s{::Quiz$}{::Question};
    ( my $question_module = $class ) =~ s{::}{/}g;

    my $question = eval { require "$question_module.pm" } 
                 ? $question_class->new( @_ )
                 : NHB::QuizMaster::Question->new( @_ )
                 ;
                
    push @{ $self->questions }, $question;
    $question;
}
[download]