Change external variables inside a higher order function

[gchumillas]

Hi! I'd like to modify the variable x inside my_higher_order_func, and the following script works correctly. However, I found it a bit cumbersome, as I have to create an intermediate pointer variable. Is there an easier solution?

pub fn my_higher_order_func(f fn ()) {
	f()
}

mut x := 0
x_ref := &x
my_higher_order_func(fn [x_ref]() {
	unsafe { *x_ref = 100 }
})

println(x) // prints 100 (OK!)

[JalonSolov]

No. As it says in the docs, Inherited variables are copied when the anonymous function is created. The only way to modify the original value is to use a reference they way you're doing it - otherwise, you're only modifying the copy.

[changrui]

Is this a bug? It relly print out 100.

[gchumillas]

No, it's not a bug. I was just wondering if there was an easier way to pass variables by reference. Something like this:

pub fn my_higher_order_func(f fn ()) {
	f()
}

mut x := 0
// code.v:6:30: error: unexpected token `&`, expecting name
my_higher_order_func(fn [mut &x]() {
	usafe { *x = 100 }
})

println(x) // prints 100 (OK!)

But we can't.

[changrui]

The fellowing code is also running well, why? (run under v playgroud)

x := 0
x_ref := &x

unsafe {
	*x_ref = 100
}
println(x)
// prints 100 (OK!)

[JalonSolov]

Because you're not using an anonymous function.

[changrui]

x is immutable, but it is changed, is it right?

[JalonSolov]

Yes, because you're changing it through a reference in an unsafe block. unsafe is V's "escape hatch" to allow you to do things you wouldn't normally be able to do.

[gchumillas]

Finally I solved it using a Ref.new utility (probably this is the idiomatic way):

pub struct Ref[T] {
pub mut:
	value T
}

pub fn Ref.new[T](value T) &Ref[T] {
	return &Ref[T]{ value: value }
}

pub fn my_higher_order_func(f fn ()) {
	f()
}

mut x := Ref.new(0)
my_higher_order_func(fn [mut x]() {
	x.value = 100
})

println(x) // prints &Ref[int]{ value: 100 } (OK!)

[jorgeluismireles]

This also works:

pub struct Ref[T] {
pub mut:
	value T
}

pub fn my_higher_order_func(f fn ()) {
	f()
}

mut x := &Ref{ value:0 }

my_higher_order_func(fn [mut x]() {
	x.value = 100
})

println(x) // prints &Ref[int]{ value: 100 } (OK!)

But mut x := Ref{ value:0 } (without &) does not work.

[gchumillas]

That's right. That's why the Ref.new function returns a reference to an instance (rather than the instance itself).