I'd be more inclined to remove the @classes array (unless it makes other things in your code more convenient) -- and push onto a departments hash to begin with. Something like:

my %departments;
while( $sth->fetchrow() ) {
    push @{$departments{$department}}, {
            class      => $class,
            department => $department,
            count      => $count,
    };
}

my @departments = map { 
        { department => $_, classes => $departments{$_} } 
} keys %departments;
[download]

You could also sort on the keys to create the final array sorted by department if desired.

This is pretty much what I've been looking for...

Something seemed redundant, and I assumed it to be %departments, but you're right; @classes is not really needed.

And ++ on the sort. I forgot to sort my keys, since it showed up fine when I was testing, but that was due too a not large enough dataset :-)

Thanks.

Not that it means anything of course, since any improvement I get here means a speed increase of thousandths of a second (guessing), but I was curious....

[ar0n]

#!/usr/bin/perl -w

require 5.6.0;
use strict;
use Data::Dumper;

our @input = ({ class => "Chemistry", department => "v6", count => 18 
+},
              { class => "German I", department => "v6", count => 27},
              { class => "French II", department => "h4", count => 9 }
+);


our %collate;

foreach (map { [ $_->{department}, $_ ] } @input) {
  push(@{$collate{$$_[0]}}, $$_[1]);
}

our @output = map { { department => $_, classes => $collate{$_} } } ke
+ys %colla\
te;

print Data::Dumper->new([\@output], [qw|*output|])->Dumpxs;
[download]

Update:

(Subanswer: It isn't)

Clearly I'm insufficiently awake. %collate can be built like this:

foreach (@input) {
 push(@{$collate{$_->{department}}}, $_);
}
[download]

Update II

tilly suggested I point out that the code doesn't work on older Perls, even 5.005.

Afaict, the changes for perl 5.005 would be:

• replace "require 5.6.0" to the appropriate version
• either change "our $foo" into "my $foo", or separate the declaration and assignments, and declare them in a "use vars qw($foo)" construct.

ar0n, I think you are on the right track. I also try to limit the usage of sythentic variables, however IMHO using hashes isn't as wasteful as you might think. Their ability for fast lookups and their natural grouping properties make them a perfect choice for this problem.

The key is to use the hash to group your data, then flatten it into an array when you are done. Please consider the following code:

my %departments;

while($sth->fetch) {

  $departments{ $department }{department} ||= $department;

  push @{ $departments{ $department }{classes} }, {
    class      => $class,
    department => $department,
    count      => $count,
  };

}
[download]

Now you need to transform it into a structure that HTML::Template will understant and use. The entire first level of the hash, the keys, are redundant, and something we don't need now. So we'll slice it away and flatten the structure into and array reference:

$tmpl->param(
  departments => [values %departments],
);

#Note: $tmpl is an HTML::Template object
[download]

Or if you'd like to sort the department output:

$tmpl->param(
  departments => [@departments{ sort keys %departments }],
);
[download]

Update 1: Removed extra code that was not pertinent to the problem. Also, changed the while loop code to be closer in-line to what ar0n had.

Update 2: Added sort to flattening example.