If you think about it, a package symbol table (stash) *is* a hash, so the individual package variables within a package who's only purpose is to hold constants or configuration parameters is already organised as you would like it.

If you then avoid exporting the individual variables and use them as $config::one, $config::two etc. then you've got the best of both worlds.

The variables are nicely organised, and you also get typo checking at compile time:

>perl -c -wE"package x;our $fred=50;package main; print $x::fred,$x::d
+erf"
Name "x::derf" used only once: possible typo at -e line 1.
-e syntax OK
[download]

Need a little clarification. So it's better to export a collective hash (reference) or individual variables (as suggested by JavaFan)?

's better to export a collective hash (reference) or individual variables (as suggested by JavaFan)?

Personally, I wouldn't export either.

As I attempted to show above, I'd use individual package (our) variables, and use them via fully qualified references:

package MyConfig;

our $one = ...;
our $two = ...;
[download]

use MyConfig;

...
if( $x <= $MyConfig::one ) {
...
[download]

All the variable are nicely contained within the package stash (symbol table hash); warnings are issued for typos; and where they come from is clearly defined. And by not importing them, you avoid namespace clashes.

If they are truly constants, then I use constant and avail myself of the optimisations that brings.

---

Examine what is said, not who speaks -- Silence betokens consent -- Love the truth but pardon error.

"Science is about questioning the status quo. Questioning authority".

In the absence of evidence, opinion is indistinguishable from prejudice.

RIP an inspiration; A true Folk's Guy

But the main problem I have is the same problem I have with neither using strict, nor warnings.

use strict;
use warnings;
my $chapters = {
   one => 'Chapter 1: AAA',
   two => 'Chapter 2: BBB',
   three => 'Chapter 3: CCC',
};
say "We start with $chapters->{noe}";   # Compiler neither gives an er
+ror, nor a warning.
[download]

package chapters;
our $one = 'Chapter 1: AAA';
our $two = 'Chapter 2: BBB';
our $three = 'Chapter 3: CCC';
package main;
use strict;
use warnings;
say "We start with $chapters::noe";  # Compile time error.
[download]

I see your point.

If I've several groups of variables (other than chapters), I would have to have a module for each group e.g. Chapters.pm, Authors.pm, References.pm.

To avoid that, I have a module that stores all the different groups of variables. To help me organise the code, I use a hash reference for each group e.g. $chapters, $authors, etc (so $chapters stores all the chapter information, $authors stores all the author information, etc)

Hm...don't know. Does that sound strange or silly?

You don't need a different module for each group (Well, "module" is a very loose definition, so what follows you may consider different modules. But it's all can be one file):

package Whatever;  # Really, whatever. Can even omit this line.
use strict;
use warnings;
#
# Chapters go here
#
$Chapter::one = 'Chapter 1';
$Chapter::two = 'Chapter 2';
#
# Authors go here
#
$Author::LW = 'Larry Wall';
$Author::KV = 'Kurt Vonnegut';
#
# References go here
#
$Reference::foo = 'Over there -->';
$Reference::bar = 'Switch doors!';
$Reference::baz = 'Yesteryear';
[download]