The parameter type "voidptr" for partial functions of the array is prone to ambiguity

[tzSharing]

Many array functions have 'voidptr' type parameters,such as the insertion function: pub fn (mut a array) insert (i int, val voidptr) {}, you may think that the second parameter should be a pointer type, but in fact it can be passed in as either “array.data” or “array”, and it runs normally, but the result is very different. Just like the following code:

fn main() {
	mut arr := [1, 2, 3]
	a := [-1]
	arr.insert(0, a.data)
	println(arr.str())

	arr = [1, 2, 3]
	arr.insert(0, a)
	println(arr.str())
}

out:

C:\Users\TZ\Desktop>v run test.v
[33173472, 1, 2, 3]
[-1, 1, 2, 3]

I think such function signatures are not intuitive and prone to ambiguity. Maybe it can be designed like this pub fn (mut a array) insert [T] (pos int, arr [] T) {}, I don't know if it's feasible. In short, I think it's necessary to set some explicit constraints to avoid a lot of unexpected behavior lurking in your code and breaking at any time.

[JalonSolov]

You are completely correct that using voidptr to mean any is error-prone, just as using any is error-prone and lazy in other languages.

There is nothing that V can do about this. The functionality is there because it is truly necessary in some cases (such as interop with C and other languages), but many people are simply too lazy to do the correct thing, so they use voidptr because it is "easy".