| 14 Aug 2025 |
 emily | yes | 16:42:22 |
| emily | it was changed when banning overflow in the Nix language | 16:42:25 |
| emily | IMO that part of the change was a mistake | 16:42:31 |
| emily | well, it would be just a difference of opinion if the negative values were handled consistently | 16:42:44 |
 jade_ | i don't know what it should do | 16:44:22 |
| jade_ | i chose to make it behave conservatively | 16:44:40 |
| emily | builtins.fromJSON "-9223372036854775809"'s behaviour is not conservative though | 16:46:56 |
| emily | see | 16:47:06 |
| emily | JSON has only one numeric type and we certainly want everything that fits in a Nix integer to be represented as one (because Nixpkgs expects that). so the two options are optimistically coercing JSON literals that look like Nix integers into Nix integers and leaving the rest as floats, or coercing JSON literals that look like any kind of integer into Nix integers, leaving ones that are clearly floats as floats, and rejecting the rest. currently, we do neither | 16:48:52 |
| jade_ | correct, I would class that as "a bug" | 16:49:20 |
| emily | I think the former is what makes the most sense per JSON semantics and the general behaviour pointed at by the RFCs. the latter is defensible too. but picking one for positive values and another for negative values because of how nlohmann_json interacts with C++ numeric types not so much | 16:49:22 |
| emily | ok. but I think it is hard to define these erroring semantics in a way that doesn't have weird edge cases wrt how JSON works | 16:50:09 |
| jade_ | I think that getting a float in nix in general because it's nix is usually an undesired outcome | 16:50:14 |
| emily | for instance, there are also JSOn literal floats that cannot be represented | 16:50:22 |
| jade_ | but alsoooo, often you want to passthru json | 16:50:26 |
| emily | * for instance, there are also JSON literal floats that cannot be represented | 16:50:26 |
| emily | FWIW, the Nixpkgs integer parsing functions specifically reject the non-integer case, as I said | 16:51:02 |
| jade_ | so it is probably reasonable to try to just tolerate any numbers as losslessly as possible and eat the weird edge case that it's a float if it's too big | 16:51:05 |
| emily | so returning floats does not make those behave spookily | 16:51:09 |
| emily | also, I don't think this should be a major consideration, but I suspect that making the negative case error out with nlohmann_json would be a pain | 16:51:33 |
| emily | because it is already a float by the time you see it, because of being a value that does not fit into the integer types | 16:51:59 |
| emily | I mean I guess you can compare the float but float precision issues may make that weird | 16:52:13 |
| emily | and you have to determine whether it "could be" an integer | 16:52:20 |
| emily | let's put it this way | 16:52:35 |
| emily | if we were going to hard-reject JSON integer values | 16:52:40 |
| emily | it should be based on the -(2^53)+1 to (2^53)-1 interoperable range | 16:53:09 |
| emily | and happen on the serialization end as well | 16:53:18 |
| emily | (IMO) | 16:53:22 |
| emily | that would be undesirable though because of fromJSON being abused for general integer-parsing | 16:53:32 |
| emily | so we're already outside the bounds of the fully interoperable JSON format | 16:53:44 |
