Is zero value of `sermver.Version` safely used?

[your-diary]

As far as I tested, the zero value of semver.Version represents 0.0.0, which is a valid semver version, but is it safe to use this value?

It is possible that the value looks like 0.0.0 but its internal representation is somehow in uninitialized state and thus it is unsafe to use the zero value.

The document says nothing about it.

[mattfarina]

It's worth reading https://semver.org/ to understand how the versioning works.

0.0.0 is a valid semantic version according to the specification. In practice you would rarely, if ever, see it. I don't think I've ever seen it. Since it's valid, this package allows it. If you won't want to, it's possible to do that checking in your own application.

[your-diary]

@mattfarina
Thank you for your reply!

Actually the question is not "is 0.0.0 valid and safe in semver" but "is zero value of semver.Version safely used". By "zero value", I mean zero value in Golang.

As far as I tested with String() method, the zero value seems to represent 0.0.0 in semver:

package main

import (
	"fmt"

	"github.com/Masterminds/semver/v3"
)

func main() {
	//zero value
	{
		var v semver.Version
		fmt.Println(v.String()) //=> 0.0.0
	}

	//explicit `0.0.0`
	{
		v, err := semver.StrictNewVersion("0.0.0")
		if err != nil {
			panic(err)
		}
		fmt.Println(v.String()) //=> 0.0.0 (exactly the same as above)
	}
}

However, just because the string representations of two objects are the same doesn't mean the two objects are identical.

It is possible that using zero value is not intended by the author or/and is in an apparently valid but internally invalid state. At least their internal representations doesn't match, checking via pp package:

//zero value
semver.Version{
  major:    0,
  minor:    0,
  patch:    0,
  pre:      "",
  metadata: "",
  original: "",
}

//explicit `0.0.0`
&semver.Version{
  major:    0,
  minor:    0,
  patch:    0,
  pre:      "",
  metadata: "",
  original: "0.0.0",
}

Additionally, even if explicit 0.0.0 was exactly the same as the zero value in the current version, relying on this behavior would be unsafe in terms of Hyrum's law because "how zero value works in this package" is not a part of the document. If this omission is intentional, the behavior of zero value can be changed in a future version without breaking change.

The essence of this issue/question is: could someone give me an explicit statement?

The documentation of decimal package, for example, is very explicit in this regard:

The zero-value is 0, and is safe to use without initialization