How to differentiate int null and defaulted to zero from int actually equal to zero?

I am a long time python user moving to Go, and I still have some issues to reacquire basic skill to manage typing and pointer.

I have a program receiving event from RabbitMq (But the problem would be the same no matter what transport we are talking about). One of the even contain an optional field F1 typed as int.

My understanding is, if the field is not present in the event, then go will default it to 0. But 0 is a valid value for that field, and I need to differentiate cases where the value is 0, and cases where the value is non defined.

I thought to make my field a *int to actually have "nil" as a value. But then when when a receive an event, will F1 be set to the actual pointed value, or the value address from the sender?
Do I have any other alternative?

In most cases, using a pointer to the value makes sense. E.g

type RabbitMessage struct {
    F1 *int `json:"f1"`
}

The exact details of how this will work depends on how you serialise your data before sending it over RabbitMQ. If you are using JSON, then there should be no issue with this as both a null value, and an omitted value, will be represented in Go as nil. When the value is provided, it will be set to the value you expect (it will not use the address from the sender).

If you control only the receiver program, then AFAICT you can not differentiate between an int that has been automatically initialized to 0 by go from an int that has been set to 0 by the sender.

If you can modify the sender program though, an alternative could be to add a boolean field along with your int, telling whether the int is set or not. Then on the receiving end you can check whether the boolean is true or not.

You can also send a pointer to an int:

type Message struct {
    Value *int `json:"value"`
}

message := Message{Value: 4}

Be aware though that when unmarshalling this you'll get an int pointer you'll need to dereference.

"Do I have any other alternative?" -- Yes, you can define a custom type, similar to sql.NullInt64.

type OptionalInt struct {
	Int     int
	IsValid bool
}

func NewOptionalInt(i int) OptionalInt {
	return OptionalInt{Int: i, IsValid: true}
}

func (o *OptionalInt) UnmarshalJSON(data []byte) error {
	if string(data) != "null" {
		if err := json.Unmarshal(data, &o.Int); err != nil {
			return err
		}
		o.IsValid = true
	}
	return nil
}

func (o OptionalInt) MarshalJSON() ([]byte, error) {
	if o.IsValid {
		return json.Marshal(o.Int)
	}
	return json.Marshal(nil)
}