Value Types in Function Parameters

[tweekzter]

Hi,

I'm having problems getting used to the way V handles function parameters.

In most languages (C, C++, Java, JavaScript, PHP, Go, Rust, ...) you can pass by value to functions and then mutate the parameter (the local copy). That's pretty much how pass by value is explained (and tested) in any tutorial. Transfering this behavior to V, it would look like this:

fn foo(mut a int) { // pass by value + let the parameter be mutable
        ...
        a = 5
        println(a)
}

a := 4
foo(a)
println(a) // 4 - of course, as its pass by value

This of course, does not work in V.
The compiler will tell you that mutable arguments are only allowed for arrays, structs, pointers, etc. which basically means, it just works for reference types. You cannot mutate a value type function parameter (not even a struct btw).

Although it is possible to assign the value type parameter to a new variable, which you can then mutate.

fn foo(a int) {
	mut b := a // copy by value + let the variable be mutable
	b = 5 // now I can mutate a value type
	println(b) // 5
}

a := 4
foo(a)
println(a)

So, why not immediatly let a be mutable?
The mut keyword states that a variable is mutable. It works for value types at assignments. Why not allow it for parameters?
If "mut" in the parameter declaration is meant to indicate that the parameter is a reference (that it will change the value of the calling variable), the type annotation should be sufficient (&int, &Foo, or whatever). "mut" should not indicate a reference, but just make the variable (and eventually its reference) mutable.

[tweekzter]

Just a small example where this could be useful:

fn double_n_times(val u32, n u32) u32 {
	mut v := val // this line would not be necessary
	for i := 0; i < n; i++ {
		v *= 2
	}
	return v
}

Sure, this is not a tragedy, but in a concise and simple language that would come in handy, especially as you can do it almost anywhere else as well.