Should `Float.parse/1` handle overflows gracefully?

[joshuap]

When I call Float.parse/1 with an exponent that is too large, Erlang raises an ArgumentError:

iex(1)> Float.parse("12.345e308")
** (ArgumentError) argument error
             :erlang.binary_to_float("12.345e308")
    (elixir) lib/float.ex:67: Float.parse_unsigned/4

The error isn't communicative, and the documentation for Float.parse/1 does not mention it. Based on the current documentation I would expect :error to be returned instead, for example:

joshuap@89b65af

~/code/elixir ‹float_exponent_fix› » bin/elixir lib/elixir/test/elixir/float_test.exs                                                                  18 ↵
...

  1) test parse (FloatTest)
     lib/elixir/test/elixir/float_test.exs:6
     ** (ArgumentError) argument error
     stacktrace:
       :erlang.binary_to_float("12.345e308")
       (elixir) lib/float.ex:67: Float.parse_unsigned/4
       lib/elixir/test/elixir/float_test.exs:35

..

Finished in 0.2 seconds (0.2s on load, 0.00s on tests)
6 tests, 1 failure

Would this be desired behavior to add, or is the exception expected?

[josevalim]

Although I think the exception could be better, there isn't much we can do in this case as we are delegating to the underlying erlang function.

[joshuap]

@josevalim thanks for checking it out. Fwiw, one reason I think the behavior is inconsistent is that the code is eliminating similar exceptions which would otherwise be raised by the erlang function. I can demonstrate this with String.to_float/1 which appears to delegate to the same function but without the guards that prevent similar ArgumentErrors from being raised from Float.parse/1 (instead :error is returned):

iex(3)> String.to_float("++2.35")
** (ArgumentError) argument error
    :erlang.binary_to_float("++2.35")
iex(3)> Float.parse("++2.35")
:error
iex(4)> String.to_float("12.345e308")
** (ArgumentError) argument error
    :erlang.binary_to_float("12.345e308")
iex(4)> Float.parse("12.345e308")    
** (ArgumentError) argument error
             :erlang.binary_to_float("12.345e308")
    (elixir) lib/float.ex:60: Float.parse_unsigned/4

I ran into this issue while debugging this issue with the logfmt package. I'm pretty sure we'll have to resort to rescuing ArgumentError exceptions in that code (since we have no control over the input), and that felt a bit counter-intuitive given the documentation.

[josevalim]

Another point to discuss is this: is this an invalid float or a system limit? Because the number is valid, right? Or is it an invalid float, regardless of the platform you are running on?

[joshuap]

I think the number itself is valid, but it's overflowing the limit for the size of a float. For example you can reduce the exponent by 1 and Elixir will parse it correctly:

iex(7)> Float.parse("12.345e307")
{1.2345e308, ""}

Ruby behaves the same way but returns Infinity instead of raising an exception:

irb(main):004:0> 12.345e307
=> 1.2345e+308
irb(main):005:0> 12.345e308
=> Infinity

[josevalim]

I see. I think returning :infinity would be even more confusing. :( I think we should stick with "won't fix" until we have a better idea of how to handle this, sorry.

[joshuap]

Fair enough. To clarify, the problem is that returning :error currently indicates that the number was invalid, but since the number is technically valid in this case returning :error would be too confusing? Totally agree that returning :infinity would be even more confusing. 👍

Let me know if you think I could update the documentation to mention this issue and I'd be happy to submit a PR for that.

[josevalim]

Exactly @joshuap. And I think improving the docs would be great! Thank you!