I guess the unspoken implied behavior of a function named "int()" can be interpreted more ways than I expected. When I use "int()" in perl, what I actually wanted was C's cast-to-int or JavaScript's parseInt(), followed by making assumptions that I have an integer safe for any integer purposes.

Having learned about these edge cases, now I need to go back through all the controllers I've written and fix:

  my $count= int($c->request->params->{count});
  $c->detach(HTTP => 422, ["Invalid count"])
    if $count < 0 || $count > $limit;
[download]

because passing NaN to the controller would let a non-integer value leak through to the code beyond.

I feel like 'int' ought to have a stronger contract of doing what's written on the label. If it can't convert to an int, it ought to return undef or 0, not just ignore the attempt

int doesn't contract to return an IV; it contracts to return the integer portion of the expression given. An infinitely large floating point would convert to an infinitely large integer, so infinity is still the logical conclusion (IMO).

In my mind, perl's int is equivalent to c's math.h:'trunc', not the int typecast in c.

#include <math.h>
#include <stdio.h>
int main()
{
    double x;
    x = 3.14;      printf("trunc(%f) = %f\n", x, trunc(x));
    x = -2.718;    printf("trunc(%f) = %f\n", x, trunc(x));
    x = +INFINITY; printf("trunc(%f) = %f\n", x, trunc(x));
    x = -INFINITY; printf("trunc(%f) = %f\n", x, trunc(x));
    x = +NAN;      printf("trunc(%f) = %f\n", x, trunc(x));
    x = -NAN;      printf("trunc(%f) = %f\n", x, trunc(x));
}
[download]

trunc(3.140000) = 3.000000
trunc(-2.718000) = -2.000000
trunc(inf) = inf
trunc(-inf) = -inf
trunc(nan) = nan
trunc(nan) = nan
[download]

The docs for int could be improved to say what it does on those edge cases (the trunc docs that I linked do explicitly define those behaviors), but I personally think that int returns the right thing for those inputs, and for me, it is the Answer of Least Astonishment.

Your particular trunc might have that behaviour, but trunc general might not.

The spec simply describes trunc as follows:

The trunc functions round their argument to the integer value, in floating format, nearest to but no larger in magnitude than the argument.

The spec simply describes what it returns as follows:

The trunc functions return the truncated integer value.

Passing an infinity or a NaN is therefore undefined behaviour. Anything could happen.