In article <356749eb.14708...@cnews.newsguy.com>,

Still, if you want something cute, how about:

        sub is_leap {
          my $y = shift;
          !($y % 400 xor $y % 100 xor $y % 4);
        }

Maybe it bothers you that you alsways do three divisions.  In that
case use

        sub is_leap {
          my $y = shift;
          !($y%4 or ($y%100 xor $y%400));        
        }

Or maybe
    !( $year%4 || !($year%100) && $year%400 )

I would never use ``!(X%Y)''.  It's hard to understand.
I'd prefer (X%Y==0) instead:

    !( $year%4 || ($year%100==0) && $year%400 )

Reversing the sense of the test might (or might not) make it more
understandable?

        sub regular_year {
          my $year = shift;
          $year%4 || ($year%100==0) && $year%400
        }

There's always the fighting-without-fighting approach:

        %is_leap = map {($_ => 1)} (1201 .. 2399);
        map {$is_leap{$_*100} = 0} (13..15, 17..19, 21..23);

        sub is_leap {
          $is_leap{$_[0]};
        }

You know, this whole exercise seems like a waste of time.  Who cares
if your leap year function is efficient?  Is it a bottleneck?

Maybe this is a good opportunity to point out that the point of leap
years is to make the length of the calendar year more closely
approximate the length of the solar year, and that all intercalation
schemes are inaccurate.  The Gregorian Calendar was devised when
people had been using the Julian system for long enough to notice the
inaccuracies.  But there's a rule that we could adopt that is simpler
than the Gregorian system *and* more accurate.  Under the Dominus
Calendar, a year is a leap year if and only if:

        sub is_leap { $_[0] % 33 % 4 == 0 }