for ( 0 .. $#{ $hash{$set}{data} } ) {
    $hash{$set}{min} = $hash{$set}{min} < $hash{$set}{data}[$_]
                     ? $hash{$set}{min} 
                     : $hash{$set}{data}[$_];
}
[download]

I personally find the above solution easier to read. However, since this is in a loop, and regular ? : evaluates the data twice, your proposed operator could be considerably faster in some cases. Naturally, the premature optimization alarms are ringing here, so I'm going to stop typing now (:

----
I wanted to explore how Perl's closures can be manipulated, and ended up creating an object system by accident.
-- Schemer

Note: All code is untested, unless otherwise stated

$x =min $x, $y; # p5
[download]

I think you should at least consider writing such code more like:

my $set = $hash{$set};
my $data = $set->{data};
for (@$data) {
  $set->{min} = $set->{min} < $_ ? $set->{min} : $_;
}
[download]

use List::Util qw(min);
$hash{$set}{min} = min @{$hash{$set}{data}};
[download]

for (@{$hash{$set}{data}}) {
    $hash{$set}{min} = $hash{$set}{min} < $_
        ? $hash{$set}{min}
        : $_;
}
[download]

my $min := $hash{$set}{min};
for(@{%hash{$set}{data}}) { $min = $min < $_ ? $min : $_ }
[download]

Makeshifts last the longest.

List::Utils is great and was one the reasons I got around to upgrading. It replaced about half the routines in my personal utils module. The problem is that I need the min and max of each dataset, and iterating each dataset twice isn't ideal with huge datasets.

I agree with your reduction when the array is of a reasonable size, but each dataset is 786,432 elements, there are several datasets and the operation isn't a one-off, so building a list in the for loop is kind of expensive I think? Hence the choice to use the lazy evaluation of the range op in a for loop to index the elements. That problem goes away once we get lazy-evaluating in P6.

It still irks me that I have to type the operands, to what is essentially a binary operation, twice each, but it seems I'm the only one who sees that as a problem, and I don't relish causing, let alone being involved in, a 3 year p5p flame fest which I was told above is what it took to get ||= implemented:(.

It's the same "I know that everything is available in the cpu for the processing required" type ire that I feel about the need to do

my $n;
my ($div, $rem) = ( int($n/10), $n % 10 );
[download]

as I pontificated on at A better mod (%) operator?. It's not a "performance thing",

 my ($div, %rem) = $n %% 10;

just seems cleaner. That I know that both values are available in the registers after either / or % means that even hiding the double division within a sub or overloading % or whatever still doesn't satisfy my sense of "once and once only:)

---

Examine what is said, not who speaks.
"Efficiency is intelligent laziness." -David Dunham
"When I'm working on a problem, I never think about beauty. I think only how to solve the problem. But when I have finished, if the solution is not beautiful, I know it is wrong." -Richard Buckminster Fuller

As for the single-pass problem, you can do that too:

use List::Util qw(reduce);

@hash{$set}{qw(min max)} = @{ reduce {
    return [ $a, $b ] if 'ARRAY' ne ref $a;
    return
        $a->[0] < $b ? [ $b, $a->[1] ] :
        $a->[1] > $b ? [ $a->[0], $b ] :
        $a;
} @{$hash{$set}{data}} };
[download]

Admittedly more hoop jumping here. Of course that doesn't address the memory problem, but in that case I'd still opt for a counter in a while loop instead. (In keeping with the corresponding use of while and each to traverse a hash.)

for my $min ($hash{$set}{min}) {
    my $data = $hash{$set}{data};
    my $i = -1;
    while(++$i < @$data) {
        $min = $min < $data->{$i}
            ? $min
            : $data->{$i};
    }
}
[download]

Makeshifts last the longest.