The problem with IEEE-754 floats is they are not guaranteed to be exact to any particular number of digits. Assert for floats will only ever accidentally match exactly.

It might be better to simply not allow == checks on pure floats... only <, >, >=, etc. Inexact matches.

The problem with IEEE-754 floats is they are not guaranteed to be exact to any particular number of digits. Assert for floats will only ever accidentally match exactly.

It might be better to simply not allow == checks on pure floats... only <, >, >=, etc. Inexact matches.

Maybe my example was not good. But the point is about the *unknown value* print instead of the real float number in comparison.

The problem with IEEE-754 floats is they are not guaranteed to be exact to any particular number of digits. Assert for floats will only ever accidentally match exactly.

It might be better to simply not allow == checks on pure floats... only <, >, >=, etc. Inexact matches.

If == is allowed for all other operations of float then why disallow for assert statements? If you are going to disallow equality operations for floats, may just disallow it completely.

Well, some people have hopes... the problem with allowing == for asserts is you will get a lot of "false negatives" (as in, they won't match when you think they should). In regular code, well, you get what you get, and people have been dealing with it for years.

For example, a very simple test might always work...

pub fn test_format() {
        f := 0.2
        assert f == 0.2
}

However, if you did several calculations before the assert, you might instead end up with

  > assert f == f64(0.2)
     Left value: 0.2
    Right value: 0.200001

I can work with a notice alert. Not an error.

That would be fine, I suppose. The problem is that many (if not most) expect floats to act the same as ints (as in, precision the same, no round-off errors, etc.), but they don't.

And when they don't, we get questions about why they don't.

So letting them know up front that using == on floats may not always work would be a good thing.

I remember I wanted to ban float1 == float2 way back, but there was a discussion with some arguments against this.

Can't find it now.

I think it makes sense.

The PR is only slightly related to x == 0.11111 etc.

It fixes printing of floating point values for all assertions, including for assert f > x, see for example:

fn test_abc() {
	f := 0.0
	assert f > 0.3
}