Golang Enum pattern that can be serialized to json

enum.go

package enum_example

import (
	"bytes"
	"encoding/json"
)

// TaskState represents the state of task, moving through Created, Running then Finished or Errorred
type TaskState int

const (
	// Created represents the task has been created but not started yet
	Created TaskState = iota
	//Running represents the task has started
	Running
	// Finished represents the task is complete
	Finished
	// Errorred represents the task has encountered a problem and is no longer running
	Errorred
)

func (s TaskState) String() string {
	return toString[s]
}

var toString = map[TaskState]string{
	Created:  "Created",
	Running:  "Running",
	Finished: "Finished",
	Errorred: "Errorred",
}

var toID = map[string]TaskState{
	"Created":  Created,
	"Running":  Running,
	"Finished": Finished,
	"Errorred": Errorred,
}

// MarshalJSON marshals the enum as a quoted json string
func (s TaskState) MarshalJSON() ([]byte, error) {
	buffer := bytes.NewBufferString(`"`)
	buffer.WriteString(toString[s])
	buffer.WriteString(`"`)
	return buffer.Bytes(), nil
}

// UnmarshalJSON unmashals a quoted json string to the enum value
func (s *TaskState) UnmarshalJSON(b []byte) error {
	var j string
	err := json.Unmarshal(b, &j)
	if err != nil {
		return err
	}
	// Note that if the string cannot be found then it will be set to the zero value, 'Created' in this case.
	*s = toID[j]
	return nil
}

func (t *Kind) UnMarshalJSON(b []byte) error {

Note that this should be UnmarshalJSON, without the capital "M" in the middle... other than that, works brilliantly, thanks!

I ran into an edge case today - you need to add the following method if you plan to unmarshal json into a map that uses a custom enum as a key (e.g. map[TaskState]string):

func (s *TaskState) UnmarshalText(b []byte) error {
	return s.UnmarshalJSON(b)
}

Without it you will get an error like this when you unmarshal:

json: cannot unmarshal number Sent into Go struct field <some field with type map[TaskState]string> of type TaskState

---

FWIW I found the docs on this confusing. The paragraph below from https://pkg.go.dev/encoding/json#Unmarshal seems to indicate that implementing json.Unmarshaler is sufficient (emphasis mine):

To unmarshal a JSON object into a map, Unmarshal first establishes a map to use. If the map is nil, Unmarshal allocates a new map. Otherwise Unmarshal reuses the existing map, keeping existing entries. Unmarshal then stores key-value pairs from the JSON object into the map. The map's key type must either be any string type, an integer, implement json.Unmarshaler, or implement encoding.TextUnmarshaler.

However, this source code comment indicates otherwise: https://cs.opensource.google/go/go/+/refs/tags/go1.21.3:src/encoding/json/decode.go;drc=b9b8cecbfc72168ca03ad586cc2ed52b0e8db409;l=630