Can you have a map with no value in go?

Question

I ask since I like that maps do not allow multiple keys. I know you can do something like the below where your values are bools or empty struct, but is there a way to get around specifying any value for your keys? Is there some advantage to having to specify an empty struct?

Related question, but focused on appending only unique values.

type N struct {}

func tengoQueCagar() {
    var map_almost_empty_value1 = map[int]bool{0:true,1:false}
    var map_almost_empty_value2 = map[int]struct{}{0:struct{}{},1:struct{}{}} //long and seems like lame syntax...
    var map_almost_empty_value3 = map[int]N{0:N{},1:N{}} //shorter.. better?

    var map_not_possible_empty_value_2 = map[int]nil{0:nil,1:nil} // better than empty struct syntax... but not possible
    var map_not_possible_empty_value_2 = map[int]{0,1} // ideally possible... but not... 

    //do something...
}

If you find yourself doing `struct{}{}` a lot, you can create a shortcut variable for it. `empty := struct{}{}; map[int]struct{}{0:empty,1:empty}` — Jonathan Hall, Aug 23 '19 at 08:00
@Flimzy is this true? Maps guarantee unique keys... that must involve some overhead. — John Drinane, Aug 23 '19 at 16:00
Of course it's true, by definition. A map is an association of one thing to another. Without "another", it's not a map. — Jonathan Hall, Aug 23 '19 at 16:03
@Flimzy ok I guess I buy it by definition... I guess I'm asking... are maps and array implementation the same? — John Drinane, Aug 23 '19 at 16:09
And Go doesn't offer any sort of unique slice/array type, so using a map is appropriate. But you still must have the value portion. `struct{}{}` is the idiomatic way to do that. I think you've already got that though :) — Jonathan Hall, Aug 23 '19 at 16:10
Yeah it just smells in my noob nose. Thanks for the comments! — John Drinane, Aug 23 '19 at 16:11
Map has performance benefits, as it is hashed. So would still be faster than a slice or set. — blackmamba24, Aug 07 '20 at 04:17

score 19 · Accepted Answer · edited Aug 29 '19 at 23:08

19

struct{} requires 0 bytes to store. If you declare a map with struct{} values, you'd only be storing map keys.

There's a nice blog post about it: https://dave.cheney.net/2014/03/25/the-empty-struct

If you want to use a map like a set, it might help to declare a separate type for it:

type IntSet map[int]struct{}

And you can add some convenience methods to it, such as:

func (i IntSet) Has(v int) bool {
  _, ok := i[v]
  return ok
}

edited Aug 29 '19 at 23:08

answered Aug 23 '19 at 05:36

Burak Serdar

46,455
3
40
59

1

To add a value to the map use `i[v] = struct{}{}` – Sergey Ponomarev Feb 09 '23 at 20:59

score 12 · Answer 2 · answered Aug 23 '19 at 07:00

For a direct answer to your question: See below!

This "empty struct{} as map values trick" comes up often and the argument in favor is always of the form "so the values do not need storage space".

The other natural thing to do is use a map[int]bool.

If memory is really a constraint of your application (e.g. because you are storing millions or billions of keys in your map) then yes: use struct{}. For all other, normal cases: Using struct{} makes such map literals awkward and key lookup more complicated as you have to use the comma-ok-variant (if _,ok := m[k]; ok {.

For bool values you can do a simple m[k] which is less to type and is easier to understand.

Personally I think use of struct{} as map value is a unnecessary, premature, overly clever optimisation. If you really need to save these few bytes because your map will contain millions of entries then probably a map is not the right data structure anyway: Depending on the use case bit vectors, sparse data structures or even probabilistic data structures (bloom-, cuckoo-filters), union-find, etc. might be much better suited.

Answer: No. In a map literal you have to specify each and every key. (General rule of thumb: There is no syntactic sugar in Go; there are no clever shortcuts in Go; everything is explicit in Go.)

One downside of using `map[K]bool` for a set is miss-use where a `false` value is stored into the map. I've seen such maps used as sets where someone adding/editing the code did `m[someKey] = false` instead of `delete(m, someKey)` which of course breaks any code using `if m[someKey]` as a set membership test. — Dave C, Aug 23 '19 at 13:11
@DaveC "which of course breaks any code using if m[someKey] as a set membership test." Why? m[somekey] == false in this case. — Volker, Aug 23 '19 at 19:24
D'oh, I got it backwards, the `if m[someKey]` test keeps working but anything doing a `if _, ok := m[someKey]; ok` says it exists but someone doing a `m[someKey] = false` probably intended the key to not exist. — Dave C, Aug 24 '19 at 10:34
Yet, using bool value is the recommended way for using map as a set: https://blog.golang.org/maps#TOC_4. — Alex, Jun 18 '21 at 12:14

Can you have a map with no value in go?

2 Answers2