A good way to make zero value meaningful

I have a struct with a int16 in it represent the offset of indexes in a slice. There are 2 states for this value: 1. it can be that the offset is invalid; 2. it's meaningful and will actually represent a positive, negative, or zero value offset. Now the question is that I will allocate an array of this struct, and the default value for this int16 should be the invalid state, but the default value is 0, and 0 can also represent a valid offset with value of 0.

Currently, I use -32768 as the value to represent the invalid state, and manually initialize the array after using make. However, I don't like this approach and it doesn't follow the Go way of making the zero value meaningful. Is there a better way to approach this? I don't really want to introduce extra variables as that will take more space in memory.

When accessing the offset value, you can remap the zero value to the invalid constant through addition and subtraction. This will require obscuring the type through a Get and Set, since accessing the internal value directly will no longer be valid.

package main

import "fmt"

type Offset struct {
	// This value is not safe to use directly,
	// since it has to be mapped to/from a real offset
	mappedOffset int16
}

const InvalidOffset = -32768

func (o Offset) Get() int16 {
	// Shift values so 0 becomes InvalidOffset
	return o.mappedOffset + InvalidOffset
}

func (o *Offset) Set(i int16) {
	// Shift values so InvalidOffset becomes 0
	o.mappedOffset = i - InvalidOffset
}

func (o Offset) IsValid() bool {
	// Check if it is the actual "Go Zero"
	return o != Offset{}
}

func main() {
	var offset Offset
	fmt.Println("Apparent value:", offset.Get(), "  Internal:", offset, "  IsValid:", offset.IsValid())

	offset.Set(123)
	fmt.Println("Apparent value:", offset.Get(), "  Internal:", offset, "  IsValid:", offset.IsValid())

	offset.Set(InvalidOffset)
	fmt.Println("Apparent value:", offset.Get(), "  Internal:", offset, "  IsValid:", offset.IsValid())
}

Output:

Apparent value: -32768   Internal: {0}   IsValid: false
Apparent value: 123   Internal: {-32645}   IsValid: true
Apparent value: -32768   Internal: {0}   IsValid: false

Found a solution. I can store it using an uint16 and offset it with math.minint16. This way the default value 0 is -32768 and is treated as the invalid state, all other numbers are valid.