¿Qué es una forma idiomática de representar enum en Go?

Refiriéndose a la respuesta de jnml, podría evitar nuevas instancias de tipo Base al no exportar el tipo Base en absoluto (es decir, escribirlo en minúsculas). Si es necesario, puede hacer una interfaz exportable que tenga un método que devuelva un tipo base, de modo que esta interfaz pueda usarse en funciones del exterior que traten con Bases, es decir,

package a

type base int

const (
    A base = iota
    C
    T
    G
)


type Baser interface {
    Base() base
}

// every base must fullfill the Baser interface
func(b base) Base() base {
    return b
}


func(b base) OtherMethod()  {
}

package main

import "a"

// func from the outside that handles a.base via a.Baser
// since a.base is not exported, only exported bases that are created within package a may be used, like a.A, a.C, a.T. and a.G
func HandleBasers(b a.Baser) {
    base := b.Base()
    base.OtherMethod()
}


// func from the outside that returns a.A or a.C, depending of condition
func AorC(condition bool) a.Baser {
    if condition {
       return a.A
    }
    return a.C
}

Dentro del paquete principal a.Baser es efectivamente como una enumeración ahora. Solo dentro del paquete a puede definir nuevas instancias.

A partir de Go 1.4, la herramienta go generate se ha introducido junto con el stringer comando que hace que su enumeración sea fácilmente depurable e imprimible.

Puedes hacerlo así:

type MessageType int32

const (
    TEXT   MessageType = 0
    BINARY MessageType = 1
)

Con este compilador de código debe comprobar el tipo de enumeración

Es cierto que los ejemplos anteriores de usar const y iota son las formas más idiomáticas de representar enum primitivos en Go. Pero, ¿qué pasa si estás buscando una manera de crear una enumeración más completa similar al tipo que verías en otro lenguaje como Java o Python?

Una forma muy sencilla de crear un objeto que comience a verse y sentirse como una enumeración de cadena en Python sería:

package main

import (
    "fmt"
)

var Colors = newColorRegistry()

func newColorRegistry() *colorRegistry {
    return &colorRegistry{
        Red:   "red",
        Green: "green",
        Blue:  "blue",
    }
}

type colorRegistry struct {
    Red   string
    Green string
    Blue  string
}

func main() {
    fmt.Println(Colors.Red)
}

Supongamos que también desea algunos métodos de utilidad, como Colors.List(), y Colors.Parse("red"). Y tus colores eran más complejos y necesitaban ser una estructura. Entonces usted podría hacer algo un poco como esto:

package main

import (
    "errors"
    "fmt"
)

var Colors = newColorRegistry()

type Color struct {
    StringRepresentation string
    Hex                  string
}

func (c *Color) String() string {
    return c.StringRepresentation
}

func newColorRegistry() *colorRegistry {

    red := &Color{"red", "F00"}
    green := &Color{"green", "0F0"}
    blue := &Color{"blue", "00F"}

    return &colorRegistry{
        Red:    red,
        Green:  green,
        Blue:   blue,
        colors: []*Color{red, green, blue},
    }
}

type colorRegistry struct {
    Red   *Color
    Green *Color
    Blue  *Color

    colors []*Color
}

func (c *colorRegistry) List() []*Color {
    return c.colors
}

func (c *colorRegistry) Parse(s string) (*Color, error) {
    for _, color := range c.List() {
        if color.String() == s {
            return color, nil
        }
    }
    return nil, errors.New("couldn't find it")
}

func main() {
    fmt.Printf("%s\n", Colors.List())
}

En ese punto, seguro que funciona, pero puede que no te guste cómo tienes que definir colores repetitivamente. Si en este punto desea eliminar eso, podría usar etiquetas en su estructura y hacer un poco de reflexión elegante para configurarlo, pero espero que esto sea suficiente para cubrir a la mayoría de las personas.

Estoy seguro de que tenemos muchas buenas respuestas aquí. Pero, solo pensé en agregar la forma en que he utilizado tipos enumerados

package main

import "fmt"

type Enum interface {
    name() string
    ordinal() int
    values() *[]string
}

type GenderType uint

const (
    MALE = iota
    FEMALE
)

var genderTypeStrings = []string{
    "MALE",
    "FEMALE",
}

func (gt GenderType) name() string {
    return genderTypeStrings[gt]
}

func (gt GenderType) ordinal() int {
    return int(gt)
}

func (gt GenderType) values() *[]string {
    return &genderTypeStrings
}

func main() {
    var ds GenderType = MALE
    fmt.Printf("The Gender is %s\n", ds.name())
}

Esta es, con mucho, una de las formas idiomáticas que podríamos crear tipos Enumerados y usar en Go.

Editar:

Añadiendo otra forma de usar constantes para enumerar

package main

import (
    "fmt"
)

const (
    // UNSPECIFIED logs nothing
    UNSPECIFIED Level = iota // 0 :
    // TRACE logs everything
    TRACE // 1
    // INFO logs Info, Warnings and Errors
    INFO // 2
    // WARNING logs Warning and Errors
    WARNING // 3
    // ERROR just logs Errors
    ERROR // 4
)

// Level holds the log level.
type Level int

func SetLogLevel(level Level) {
    switch level {
    case TRACE:
        fmt.Println("trace")
        return

    case INFO:
        fmt.Println("info")
        return

    case WARNING:
        fmt.Println("warning")
        return
    case ERROR:
        fmt.Println("error")
        return

    default:
        fmt.Println("default")
        return

    }
}

func main() {

    SetLogLevel(INFO)

}