Straight from the Camel's mouth:

You can emulate a multidimensional hash by specifying more than one key within the braces, separated by commas. The listed keys are concatenated together, separated by the contents of $; ($SUBSCRIPT_SEPARATOR), which has a default value of chr(28). The resulting string is used as the actual key to the hash.

I highly recommend the Camel book: Programming Perl, 3rd Edition, published by O'Reilly & Associates.

And of course there is also the POD: perlvar:

$;

The subscript separator for multidimensional array emulation. If you refer to a hash element as

    $foo{$a,$b,$c}
[download]

it really means

    $foo{join($;, $a, $b, $c)}
[download]

But don't put

    @foo{$a,$b,$c}    # a slice--note the @
[download]

which means

    ($foo{$a},$foo{$b},$foo{$c})
[download]

Default is "\034", the same as SUBSEP in awk. If your keys contain binary data there might not be any safe value for $; . (Mnemonic: comma (the syntactic subscript separator) is a semi-semicolon. Yeah, I know, it's pretty lame, but $, is already taken for something more important.)

Consider using "real" multidimensional arrays as described in perllol.

It's a syntax you just don't see that often. Most people who know about its existance are already so comfortable with complex datastructures built by using Perl's references that this syntax is set aside in favor of a more powerful tool.

Most people who know about its existance are already so comfortable with complex datastructures built by using Perl's references that this syntax is set aside in favor of a more powerful tool.

It can be handy when dealing with large, sparse, data structures, where references would take too much memory.

use Data::Dumper;

$var{ 'a', 1, 'b', 2 } = 1;
# ^ this statement builds a simple hash table, %var

print Dumper(\%var);
[download]

$VAR1 = {
          'a1b2' => 1
        };
[download]

Careful when using Data::Dumper to dump strings.

use Data::Dumper;
$h{"a", 1, "b", 2} = 1;
$h{a1b2} = 2;
print Dumper \%h;
[download]

produces the counterintuitive:

$VAR1 = {
          'a1b2' => 2,
          'a1b2' => 1
        };
[download]

But:

use Data::Dumper;
$h{"a", 1, "b", 2} = 1;
$h{a1b2} = 2;
$_ = Dumper \%h;
s/(\P{IsPrint})/"\\x{".sprintf "%04x}", ord $1/ge;
print
[download]

reveals:

$VAR1 = {
          'a1b2' => 2,
          'a\x{001c}1\x{001c}b\x{001c}2' => 1
        };
[download]

("\x{001c}" eq "\034" eq chr(28) eq $; See first reply.)

In addition to what davido posted, let me point out that "the space between the curlies" is a magical place, and exploring all its mysteries can lead to countless epiphanies.

For example, there you will find an apparent violation of the Perl dogma that says that "a list can't exist in scalar context." The context between the curlies is a scalar context; this is why, for example, in the following DB interaction, the second line initializes $hash{ 3 }:

  DB<1> @subkeys = qw( foo bar baz )
  DB<2> $hash{ @subkeys } = 5
  DB<3> x \%hash
0  HASH(0x846a000)
   3 => 5
[download]

$hash{ 'foo', 'bar', 'baz' } = 1;
[download]

This apparent violation of dogma is resolved by declaring that the commas in $hash{ 'foo', 'bar', 'baz' } are not comma operators; they receive instead special syntactic dispensation from the Holy Interpreter (I'm sure there is a bull or two written on this somewhere).

But the wonders don't end there. It is not just textual commas that receive a special dispensation, but also =>'s, and even the implicit commas in qw() expressions, which leads to great marvels such as

  DB<1> $s = qw( eenie meenie minie moe )
  DB<2> p $s
moe
  DB<3> $hash{ qw( eenie meenie minie moe ) } = 1234
  DB<4> x \%hash                                    
0  HASH(0x846a000)
   "eenie\c\meenie\c\minie\c\moe" => 1234
[download]

One last thing: the commas do not get in the way of the auto-quoting that happens inside the curlies. E.g. $hash{ 'foo', 'bar' } and $hash{ foo, bar } refer to the same thing.

Very interesting meditation here.

One could consider this idiom "The Perl Way" in-a-nutshell, --- expanding the syntax of one fundamental datastruct (hash) to emulate another (MD array), and of course there's several ways to do that...

This flexibility originating in a wish to make the language dance to the pipe of the programmer's needs & expectations, that's what makes it an effective an tool to use. And of course, --hours of fun to learn.

"Ca, ce n'est pas une Pipe"
-- allan

"default value of chr(28)"

Default is "\034", the same as SUBSEP in awk.
[download]

You are overlooking something obvious :-)

perl -wle '$c = chr(28); $d = "\034";print $c eq $d ? "true" : "false"
+'
true
[download]

cheers

thinker