I was kinda suggesting the best practice was to avoid requireing dynamic class names completely, and address the problem at a higher level.

To answer your question directly, one can require either a class supplied as a bareword or a path. There isn't a way to require a class supplied in a scalar. In order to load a dynamically constructed class name, some use eval EXPR to do the former (e.g. Module::Pluggable), and some transform the class name into a path and use the latter (e.g. if). I have no idea why one cannot do require $class;.

The second paragraph summarizes nicely the whole thread, but I cannot agree with the best practice you are suggesting which is don't use it IIUC.

eval-require is a common idiom for conditional loading of modules and there is a need for that. From a language perspective a special "use" would be better like 'use any LIST' as the intent would be much clearer. Still you don't want "use base/use parent" wars^Wdiscussions for something simply expressed in an idiomatic but inelegant way. In the end I think low-level things like these should be made core pragmas and (possibly) written in C, thriving for a minimalistic implementation.

cheers --stephan

eval-require is a common idiom for conditional loading of modules and there is a need for that.

No, you don't need either eval functions to conditionally load a module.

if (condition) {
   require Foo::Bar;
}
[download]

And you don't need eval EXPR* to do exception handling.

eval {
   require Foo::Bar;
};
if ($@) {
   require Foo::Baz;
}
[download]

You only need eval EXPR to load a module whose name is not known at compile-time. The only things I can think of that fits that description are plugins/drivers, things well served by high-level modules.

Do you have an example that requires require $class other than plugins/drivers?

* — Remember, nothing wrong with eval BLOCK (called try in some other languages). Unlike eval EXPR, it doesn't invoke the Perl compiler. That means it doesn't incure a huge speed penalty and it doesn't require careful escaping and validation its argument.