Range references instead values

I saw that range returns the key and the "copy" of the value. Is there a way for that range to return the address of the item? Example

package main

import "fmt"

type MyType struct {
	field string
}

func main() {
    var array [10]MyType

    for _, e := range array {
    	e.field = "foo"
    }

    for _, e := range array {
    	fmt.Println(e.field)
    	fmt.Println("--")
	}
}

http://play.golang.org/p/AFOGG9NGpx

Here "field" is not modified because range sends the copy of field.
Do I have to use index or is there any other way to modify the value?

The short & direct answer: no, use the array index instead of the value

So the above code becomes:

package main

import "fmt"

type MyType struct {
    field string
}

func main() {
    var array [10]MyType

    for idx, _ := range array {
        array[idx].field = "foo"
    }

    for _, e := range array {
        fmt.Println(e.field)
        fmt.Println("--")
    }
}

To combine @Dave C and @Sam Toliman's comments

package main

import "fmt"

type MyType struct {
    field string
}

func main() {
    var array [10]MyType

    for idx := range array {
        e := &array[idx]
        e.field = "foo"
    }

    for _, e := range array {
        fmt.Println(e.field)
        fmt.Println("--")
    }
}

https://play.golang.org/p/knKfziB1nce

Go's range only supports assignment by value. There is no &range because the problem it solves is too trivial.

The desired effect can be achieved as follows:

for i := range array {
    e := &array[i]
    e.field = "foo"
}

package main

import "fmt"

type MyType struct {
    field string
}

func main() {
    var array [10]MyType

    for index, _ := range array {
        array[index].field = "foo"
    }

    for _, e := range array {
        fmt.Println(e.field)
        fmt.Println("--")
    }
}

If you would like to access v's reference value (as in for i, v := range arr) to update the value of the object in the array, there are three promising (relatively simple) workarounds:

1. Like the first answer suggested, update arr[i] instead of v from within the array (e.g., arr[i] = "Hello")

2. ONLY IF your array contains a set of structs you need to update but not replace in the array's assignment, set v to arr[i] within your array and then update properties through v (e.g., v := arr[i]; v.thingSheSays = "Hello";)

3. Or, my favorite—define an array containing the object addresses. Then access the objects using a pointer from within the for-loop. Do this like so:

Input:

a, b, c := "A", "B", "C"
arr := []*string{&a, &b, &c}
fmt.Println("- Arr Value Updates:")
for i, v := range arr {
	*v = "Hello"
	fmt.Println("v's value:      " + *v)
	fmt.Println("arr[i]'s value: " + *arr[i])
}

Output:

- Arr Value Updates:
v's value:      Hello
arr[i]'s value: Hello
v's value:      Hello
arr[i]'s value: Hello
v's value:      Hello
arr[i]'s value: Hello

Hope this was able to help someone, as it initially stumped me as a newbie to golang for-loops. Feel free to share your own methods for avoiding this issue!

type arrType []string
type refArrType []*string

func ref(arr arrType) refArrType {
	refs := make(refArrType, len(arr))
	for i := 0; i < len(arr); i++ {
		refs[i] = &arr[i]
	}
	return refs
}

func main() {
	arr := arrType{"hello", "world"}

	for _, item := range ref(arr) {
		*item = "some other string"
		fmt.Println(item, arr)
	}
}

I won't encourage to use this. But if you really want to iterate over items by references then you can make a new slice of refs (not best for space complexity) and loop over that.

But with that wherever you are assigning new value to item you'll have to dereference the pointer and use it (that is what makes it bad in my opinion).
So yes I won't use this solution.

And also it works only for array of strings. You have to make new ref function for other types

It's been said in the comments already, but for those looking for answers right away, here's how you can achieve expected result by using a slice of pointers and by making the least changes to the original code.

package main

import "fmt"

type MyType struct {
    field string
}

func main() {
    // Slice of pointers instead of slice of type
    var array [10]*MyType

    // Initialize array manually
    for idx := range array {
	    array[idx] = &MyType{}
    }

    for _, e := range array {
	    e.field = "foo"
    }

    for _, e := range array {
	    fmt.Println(e.field)
	    fmt.Println("--")
    }

}

Here it is in playground

package main

import "fmt"

type MyType struct {
	field string
}

func main() {
	var array [10]MyType

	for index := range array {
		array[index].field = "foo"
	}

	for _, e := range array {
		fmt.Println(e.field)
		fmt.Println("--")
	}
}