A value from a map by key is a copy not a reference.

[jorgeluismireles]

Describe the issue

I spend some time to realize that by getting a value from a map we get a copy instead a reference. So when we need to do an accumulator it will be fail if we try to update just the copy. Seems documentation is not clear about this:

It's also possible to use an or {} block to handle missing keys:

You can also check, if a key is present, and get its value, if it was present, in one go:

I went to the docs to check how to detect a missing key but it doesn't say that the value found is a copy. The same happens using if/else or or { } forms. Next program show the difference:

struct Accumulator {
mut:
	data map[string][]int
}

fn (mut a Accumulator) push_fail(key string, value int) {
	if mut copy := a.data[key] {
		copy << value		
	} else {
		a.data[key] = [ value ]
	}
}

fn (mut a Accumulator) push_ok(key string, value int) {
	if _ := a.data[key] {
		a.data[key] << value		
	} else {
		a.data[key] = [ value ]
	}
}

fn main() {
	mut ok := Accumulator{}
	mut bad := Accumulator{}
	for number in [ 1, 2, 3, 4, 5 ] {
		key := if number % 2 == 1 { 'odd' } else { 'even' }
		ok.push_ok(key, number)
		bad.push_fail(key, number)
	}
	println('ok ${ok}')
	println('bad ${bad}')
}

Produces

ok Accumulator{
    data: {'odd': [1, 3, 5], 'even': [2, 4]}
}
bad Accumulator{
    data: {'odd': [1], 'even': [2]}
}

Links

https://docs.vlang.io/v-types.html#maps

Note

You can use the 👍 reaction to increase the issue's priority for developers.

Please note that only the 👍 reaction to the issue itself counts as a vote.
Other reactions and those to comments will not be taken into account.

[huly-for-github]

Connected to Huly®: V_0.6-22042

[EmmaTheMartian]

This quirk caught me up these past few days in my project... It would be very nice to see it mentioned in the docs

[spytheman]

I think, that it may be a bug, i.e.:
if mut x := a.data[key] { should produce a reference, that allows you to modify the value in the map directly, through x = value, or x << arr etc .

@medvednikov what do you think?

[jorgeluismireles]

if mut x := a.data[key] { should produce a reference

I think V tries to help the programmer transforming sometimes a mut value by a reference, but the problem is the "sometimes". For instance you cannot write fn (mut x &Struct)() { ... } because V says is redundant, but then here results mut wasn't a reference and (I think) the final user gets confused. I found also this problem similar in issue #23166 mut array passed to its closure.

Another question is how expensive is the current copy or clone, say []int value were a larger struct, when here we wanted only know if the key already exists.

[jorgeluismireles]

I check Golang, and also a map inspection returns a copy which can not be used for an accumulator.
Next program in Go requires (as V now) not use the copy but the whole go append form
a.data[key] = append(a.data[key], value)

package main

import "fmt"

type accumulator struct {
	data map[string][]int
}

func (a *accumulator) push(key string, value int) {
	if copy, ok := a.data[key]; ok {
		//copy = append(copy, value) DOES NOT WORK
		_ = copy
		a.data[key] = append(a.data[key], value) // WORKS
	} else {
		a.data[key] = make([]int, 0)
		a.data[key] = append(a.data[key], value)
	}
}

func main() {
	a := &accumulator{
		data: make(map[string][]int, 0),
	}
	for _, number := range []int{1, 2, 3, 4, 5} {
		key := "odd"
		if number%2 == 1 {
			key = "even"
		}
		a.push(key, number)
	}
	fmt.Printf("data %v\n", a.data)
}

data map[even:[1 3 5] odd:[2 4]]

Program exited.

Again, I wonder how expensive is returning copies that cannot be used to accumulate specially when the values were big objects.

I think V's mut could be a difference to return a non expensive reference and make this pattern more efficient. So this issue could be also a Feature request.

Edit: there where errors with odd and even were reversed.