Mixing 0x number prefix with float suffix results in unexpected behavior

[mattrberry]

➜  ~ crystal eval 'puts 0x00_f32'
3890
➜  ~ crystal --version
Crystal 1.6.1 (2022-10-21)

LLVM: 14.0.6
Default target: aarch64-apple-darwin21.6.0

I'd expect this to simply result in 0, as intuitively this number is "0x00 represented as a 32-bit float".

This seems to only act incorrectly with the 0x prefix and both float sizes. Binary and octal prefixes work as expected, as do integer numbers

[mattrberry]

Ah it's effectively parsing it as 0xF32

crystal/src/compiler/crystal/syntax/lexer.cr

Line 1533 in c60bcca

break unless digit && digit.to_u8! < base

I guess this is a little ambiguous since the _ preceding the suffix isn't required. It could be tricky to distinguish from 0x00F32 which is a totally valid hex literal

[straight-shoota]

I'm curious: Why are trying to use hexadecimal notation for floating point numbers?

[mattrberry]

I have no real-world use for this. I just stumbled across it while writing a test for something else in the compiler

[straight-shoota]

I don't think we can do anything about that. The f32 and f64 suffixes are also valid hex digits, so there's no way to tell them apart.
Rust shares the same number literal syntax and it works exactly the same:

fn main() {
    println!("{}", 0x00_f32); // => 3890
}

Hexadecimal notation is very unusual for floating point numbers. That really doesn't make much sense because hex notation (as well as octal and binary) in integers is used to express the byte representation. But that's completely different for floats. When floats are written in hex, that's usually also for the internal representation. But then you can't just use ordinary literals for that.

I checked with Rust and it does not accept octal and binary notation for floating point numbers. Crystal does, though. I think we should remove support for that in Crystal as well. It's not even documented: https://crystal-lang.org/reference/1.6/syntax_and_semantics/literals/floats.html
As a result, it would be more consistent that floating point numbers can only be written in decimal notation. Only integers can be written in other bases (powers of 2).

[HertzDevil]

Hexadecimal notation is very unusual for floating point numbers

Hexfloat literals exist, can be produced by using %a in sprintf, and can be parsed by String#to_f because it relies on LibC.strtof. Unfortunately they can never appear in plain code because the decimal part becomes a method call if it begins with an alphabetical character:

"%a" % 125.0 # => 0x1.f4p+6
0x1.f4p+6    # equivalent to (0x1).f4p().+(6)

To my knowledge, of the mainstream languages only C(++) and Julia support them in plain code.

[straight-shoota]

@HertzDevil Yeah but this is a specific format for floating point numbers based on their internal representation. That's different from what's actually an integer literal with a _f32 suffix attached.

[mattrberry]

Given that Crystal doesn't require a unique character to delineate type suffixes (i.e. 0x0'f32 in Nim), I agree with your solution of removing the binary and octal notation for floats as well to reduce ambiguity