Lossless primitive types

[cart]

I'm using ron to deserialize types that are not known at compile time. It would be really nice to have the option to fully encode primitive types in ron so that type information isn't lost.

Ex: if i serialize 1u32, it will be written as 1. If I then deserialize it using deserialize_any, it will become 1u8 because it falls into the u8 range.

If instead 1u32 got serialized as 1u32, this would not be an issue. It would also allow ron to skip the any_num range checks.

I propose a new PrettyConfig::explicit_primitive_types option that enables this behavior.

[kvark]

That sounds quite reasonable to me 👍
The only concern is that this is just one more step towards the format being self-describing, and we know that we aren't going to reach there. For example, you can't reconstruct an enum type efficiently just by looking at its variants.

[cart]

Fortunately my use case doesn't require it to be fully self describing. This is the only change I want. It's just a small iterative improvement to an already working system.

[github-actions]

Issue has had no activity in the last 180 days and is going to be closed in 7 days if no further activity occurs

[kvark]

comment

[juntyr]

I think especially with #479, I'm now convinced that this is a good idea to ensure that values can roundtrip. I'll see if I can work on this tomorrow.

As I'm on it, I should also check the integer and float parsing rules to ensure that both accept _ in the correct places, such that number parsing should just be:

• identify the byte span of the number, as before
• check after this span for a number type suffix
• check if i128/u128 is allowed
• give a nice error if it's a float literal but with an int prefix
• give a nice error if it's a negative literal but an unsigned integer
• use existing parsing logic, but constrain the types to the specified ones