How to use non-nullable indices and 0-indexed lists

If I'm passing an int value in a struct (in my particular case, rpc arguments), the language does not allow the attribute to be nil. The empty value for an int is 0.

But Go uses 0-indexed arrays. I need a way to differentiate between an empty value and an index of 0. Is there an idiomatic go solution for this problem?

// this is psuedo-code I had written before hitting this problem
if (args.maybeIndex != nil) {
  doSomething(sliceOfNodes[args.maybeIndex])
}

If you encode your ints by value, then there's not much you can do about it - the default value is 0.

A common way to ensure nullability in encodings in Go is to use pointer types. Using a *int instead of an int lets you distinguish between "none" and 0.

E.g. with a JSON example, consider the struct:

type Options struct {
  Id      *string `json:"id,omitempty"`
  Verbose *bool   `json:"verbose,omitempty"`
  Level   *int    `json:"level,omitempty"`
  Power   *int    `json:"power,omitempty"`
}

And this data:

{
  "id": "foobar",
  "verbose": false,
  "level": 10
}

Note that "power" is not specified. You could write a deserializer:

func parseOptions(jsn []byte) Options {
  var opts Options
  if err := json.Unmarshal(jsonText, &opts); err != nil {
    log.Fatal(err)
  }

  if opts.Power == nil {
    var v int = 10
    opts.Power = &v
  }

  return opts
}

That sets a default value to "power", if it's not specified. This lets you distinguish between "power was not present" and "power was present and its value was 0".

If your encoding / RPC mechanism does not permit pointers, you could work around this by having another boolean field called "index present" or something like this.

Finally, consider designing your program to make it resilient to the difference between "not set" and "set to default value". IOW, just accept that default values and unspecified data are one and the same. In the long term, this will result in a cleaner design and code, and will be less error prone.