Why no enums?

Kotlin's Sealed Classes come close, they are basically sum types. The main thing Kotlin is missing on this front is pattern matching.

I can't think of any other language with enums even close to Rust enums.

Scala? https://dotty.epfl.ch/docs/reference/enums/enums.html

The language I use is informed by more than just my desires sadly. Snark aside, I’m not disparaging Go the language as much as I am commenting on how far people are willing to go to make excuses for Go devs. Poor communication and slow to design obvious solutions is frustrating.

They spend time designing over engineered SAT solvers instead of making go more pleasant

Language design is extremely challenging in general, totally agree with you there. But generics specifically is not. Everyone said excluding generics was a mistake at the beginning of the language. Generics exist in many other contemporary languages. It's a solved problem. One that Go rejected for years, for no reason, and provided no novelty with the eventual solution that they came up with.

10K ? Fetch! And here you see me complaining for waste four fetching hours in fetching design

I feel you :). I basically only downvote when it’s flat out wrong or misinformation.

Yeah, if I wanted to disallow that behavior I would probably use type struct instead of type int.

package seasons

import "fmt"

type season struct {
	name string
}

var (
	Summer = season{name: "Summer"}
	Autumn = season{name: "Autumn"}
	Winter = season{name: "Winter"}
	Spring = season{name: "Spring"}
)

func (s season) String() string {
	return s.name
}

func Parse(s string) (season, error) {
	allowed := map[string]season{
		Summer.name: Summer, 
		Autumn.name: Autumn, 
		Winter.name: Winter, 
		Spring.name: Spring, 
        }
        if v, ok := allowed[s]; ok {
                return v, nil
        }
        return nil, fmt.Errorf("invalid season: %s", s)
}

package main

import "fmt"

func main() {
	fmt.Println(seasons.Summer)
}

who is calling functions with integer literals???

There are no invalid values for every other type.

[deleted]

Strictly speaking of responsibility, all libraries you import in a major / commercial project are your responsibility as a software engineer.

This means that you (should) read the library you're importing, forking / contributing as needed and most importantly respond on your customers issues where that library interferes.

If you blindly import and hope for the best then something backfires, you're not just going to open an issue on the original library's repo (implying the issue is there). You will need to fix it yourself as well for the sake of your product and your (paying) customers.

Importing a library is a very sensitive action and that is why the LOC matter. This is another reason why developers are very fond of the standard library.

But in my personal projects, I use protobuf and gRPC too

There are more idiomatic ways of expressing enums in Go:

type Cat int

const (
  Undefined Cat = iota
  Domestic
  Feral
  Wild
)

Inspired by this, one minor annoyance I have with Go enums is that (if you use integer iota values), the "name" is lost if you wanted to go the other direction; e.g. a function accepts one of your enum types and wants to log what the name of it is, and not just its integer value. Working off the code you wrote, a possibly elegant solution to get the reverse name mapping to work and still prevent the caller from creating invalid values could be like:

type MyEnum struct {
    val string
}

// implement the Stringer
func (e MyEnum) String() string {
    return e.val
}

var ValueOne = MyEnum{"ValueOne"}
var ValueTwo = MyEnum{"ValueTwo"}
var ValueInvalid = MyEnum{"ValueInvalid"}

// how to log the enum sent
func PrintEnumName(v MyEnum) {
    fmt.Printf("You gave me a %s\n", v)
}

Then you and outside callers who use your enums can print its name; but outside callers can't create a custom/invalid MyEnum since they can't set the private val string.

You could do this with integer values too by defining a slice of all the names, if you were concerned about data size or really needed your enum to be integers:

type MyEnum struct {
    val int
}

var names = []string{"ValueInvalid", "ValueOne", "ValueTwo"}

func (e MyEnum) String() {
    // "guaranteed" in bounds since only you can
    // create valid enums in your source package
    return names[e.val]
}