Cast IntegerNode to float32 in operations like `f32 == 1.5` about expr HOT 11 OPEN

Yes! I think we can work on a proper solution for this. The solution in #610 is not correct.

What we need is to cast type to float32 only in case of lhs is float32. This should be done in patcher.

from expr.

This is how float comparison works:

package main

func main() {
	var f32 float32 = 12.34
	var f64 float64 = 12.34
	println(float64(f32) == f64) // false
}

https://go.dev/play/p/XsvrQ66pfrX

from expr.

@antonmedv I think example I gave is more like below. It is true in golang but false in expr

package main

func main() {
	var f32 float32 = 12.34
	println(f32 == 12.34) // true
}

https://go.dev/play/p/Z9SwZHGSi_J

from expr.

In golang f32 == 12.34, right hand side 12.34 will be interpreted as float32, i.e. float32(12.34). IN Expr 12.34 is a float64.

from expr.

well in golang literals are automatically casted to proper type right? in below example both float32 and float64 comparison returns true.

package main

func main() {
	var f32 float32 = 12.34
	var f64 float64 = 12.34
	println(f32 == 12.34) // true
	println(f64 == 12.34) // true
}

from expr.

Yes, type in inherited from left.

from expr.

and that is not the case for expr (please refer to my initial example) and that's why I opened issue. I believe Expr internally always cast number to flat64

from expr.

In your example number is float32

from expr.

Is this example more clear? I expect all to be true

package main

import (
	"fmt"

	"github.com/expr-lang/expr"
)

type Env struct {
	F32 float32
	F64 float64
}

var env = Env{
	F32: 12.34,
	F64: 12.34,
}

func main() {
	fmt.Printf("f32 expr: %t, go: %t\n", eval(`F32 == 12.34`), env.F32 == 12.34)
	fmt.Printf("f64 expr: %t, go: %t\n", eval(`F64 == 12.34`), env.F64 == 12.34)
}

func eval(code string) bool {
	program, err := expr.Compile(code, expr.Env(Env{}))
	if err != nil {
		panic(err)
	}
	output, err := expr.Run(program, env)
	if err != nil {
		panic(err)
	}
	return output.(bool)
}

result is

f32 expr: false, go: true
f64 expr: true, go: true

https://go.dev/play/p/GH9DSp3YFHF

from expr.

In first example expr does this

F32 == float64(12.34)

which is false.

from expr.

yeah I understand internal - that's why I sent out #610

Don't you think it's confusing though? As shown above

fmt.Printf("f32 expr: %t, go: %t\n", eval(F32 == 12.34), env.F32 == 12.34)

expr expression is false and golang expression is true in this case

from expr.