The confusion surrounding implicit conversions of different data types

[tzSharing]

The following example is very simple, essentially f32 + f64, but the type of result is very different, why? I'm confused about this, I'm not sure if this is a bug or intentional design, in short, I hope it can be designed to be easier to understand and uniform rules.

fn main(){
    v1 := f32(1.5)
    v2 := v1 + 0.5
    println('v1:${typeof(v1).name}')
    println('v2:${typeof(v2).name}') //f32

    v3 := f32(1.5)
    v4 := 0.5
    v5 := v3 + v4
    println('v3:${typeof(v3).name}')
    println('v4:${typeof(v4).name}')
    println('v5:${typeof(v5).name}') //f64
}

C:\Users\lzy\Desktop>v run test.v
v1:f32
v2:f32
v3:f32
v4:f64
v5:f64

[gechandesu]

This is not a bug.

Float literals e.g 1.0 are f64 by default unless you do explicit cast f32(1.0).

In arithmetic ops such as addition the literal will be automatically casted into left operand type, so f32(1.0) + 2.0 is the same as f32(1.0) + f32(2.0).

v1 := f32(1.5)
v2 := v1 + 0.5  // v2 is f32 too

If right operand type has bigger size than left one the resulting type will be bigger type (f64 in this case):

v3 := f32(1.5)
v4 := 0.5
v5 := v3 + v4

v5 is f64 since v4 is f64 because float literals are f64.

I agree that this topic is poorly covered in the documentation.

See also https://docs.vlang.io/v-types.html#numbers

[tzSharing]

According to you, if the operator swaps left and right values, it will produce different results, but the actual test results are not different.

fn main(){
    v1 := f32(1.5)
    v2 := v1 + 0.5
    v3 := 0.5 + v1
    println('v1:${typeof(v1).name}')
    println('v2:${typeof(v2).name}')
    println('v3:${typeof(v3).name}')


    v10 := f32(1.5)
    v11 := 0.5
    v12 := v10 + v11
    v13 := v11 + v10
    println('v10:${typeof(v10).name}')
    println('v11:${typeof(v11).name}')
    println('v12:${typeof(v12).name}')
    println('v13:${typeof(v13).name}')
}

C:\Users\lzy\Desktop>v run test.v
v1:f32
v2:f32
v3:f32
v10:f32
v11:f64
v12:f64
v13:f64

[gechandesu]

Indeed, I was not quite right. However order matters for aliased types:

type FloatAlias = f64

one := FloatAlias(1)

a := 0.3 * one
b := one * 0.3

println(typeof(a).name)
println(typeof(b).name)

// f64
// FloatAlias

[jorgeluismireles]

Also helps wondering "what golang does?". Golang does not accept adding float32 and float64, you need to cast and "type more code".

For your V section:

v3 := f32(1.5)
v4 := 0.5
v5 := v3 + v4

Go requires do a specific cast on v3 (or v4) to get v5, otherwise does not compile the program a sends a message invalid operation: v3 + v4 (mismatched types float32 and float64):

	v3 := float32(1.5)
	v4 := 0.5
	v5 := float64(v3) + v4
	fmt.Printf("v3 type is %T\n", v3) // float32
	fmt.Printf("v4 type is %T\n", v4) // float64
	fmt.Printf("v5 type is %T\n", v5) // float64

My personal opinion is V helps user preventing to do casts, but user should be aware. but always V lets you do your cast (as mandatory golang requires to) if you decide to.

[tzSharing]

It seems not as simple as we thought

println('0.5:${typeof(0.5).name}')

>v run test.v
0.5:float literal