(feature request summary) Automatic type inference of array's it variable

[esimov]

Describe the feature

Recently I was trying out the V language and I liked in how many ways you can initialize an array, but one aspect I consider a bit annoying, is that in case you want to populate an array on initialization using the it variable you have to explicitly define its type. Wouldn't be possible to infer its type directly without using type assertion?

For example if I'm trying to initialize an u8 array the compiler expect the type of the it variable to be u8, so I need to type cast to u8. It would be much nicer the compiler being able to detect the it variable underlying type without having to explicitly define its concrete type.

arr := []u8{len: 100, init: it}
println(arr)

Here if I'm not specifying the it type the compiler will throw the following error:

$ error: expected `u8`, not `int`

Use Case

I would propose instead of this:

Actual:

arr := []u8{len: 100, init: u8(it)}
println(arr)

the compiler being able to infer the it variable type based of the array's underlying type.

Desired:

arr := []u8{len: 100, init: it}
println(arr)

Version used

V 0.3.3

Environment details (OS name and version, etc.)

OS: windows, Microsoft Windows 10 Enterprise v19044 64-bit
Processor: 16 cpus, 64bit, little endian

[i582]

I like this idea! @spytheman and @medvednikov what do you think about it?

[ChAoSUnItY]

I can see it's useful in multiple use cases, however, it variable is an array index accessor, which has a larger integer data type than u8 (you can treat it as size_t in C or usize in rust).

In your case, the actual case is safe since you forced casting index into u8, which allows overflow, but the desired case is unsafe due to the strict restrictions, you'll have to prove if len would not overflow to keep it safe.

We could do some enhancement if providing len is known size at compile time, but for the desired case, it's unsafe.

[JalonSolov]

The problem comes if you declare the array len to be larger than the array type supports

arr := []u8{len: 10000, init: it}

Should V silently "wrap" the values back to 0 after it hits 255? Would you want this in all possible cases?

It is more explicit (and therefore safer) if you specify the type yourself.

The safer version of my example would be

arr := []u8{len: 10000, init: u8(it % 256)}

[medvednikov]

By the way, I think it is confusing here and should be replaced with index.

[esimov]

I can see it's useful in multiple use cases, however, it variable is an array index accessor, which has a larger integer data type than u8 (you can treat it as size_t in C or usize in rust).

I understand, that it is an array index accessor, but from my perspective the compiler should be intelligent enough to be able to transform the index to the array underlying type.

Should V silently "wrap" the values back to 0 after it hits 255?

From my perspective is much more intuitive that in case the array index reaches the underlying type maximum value the remaining slots to be filled out with the array type default value, instead of starting over from zero. The type casting in this situation does not even matter, since the it value is still bounded to the array length.

[medvednikov]

@esimov in general, I agree with you, and think it's a good idea.

[medvednikov]

By the way, thanks to @ChAoSUnItY, index is now used instead of it.