Often, within the systems we develop, we encounter constant values. One example of these values could be the representation of a registration status. In this case, consider a status that includes more variations beyond active and inactive.

If these statuses are defined as strings, their validation within the system could become a major headache. Additionally, this approach might “inflate” the binary, as each validation would involve two strings (the expected value and the value being validated).

To avoid these problems, we can use the well-known enum type. If you’re unfamiliar with this type, it is essentially a fixed or limited-size type.

To make it clearer, let’s dive into some code. Following the idea presented earlier, we’ll create an enum type to validate registration statuses.

Defining a New Type

Creating an enum based on Go’s standard types can be problematic. Let me explain. Imagine we define our status as an uint8 type. Now, suppose our system also has another enum of type uint8 for genre.

Now imagine that the value 1 represents both the Pending status and the Country music genre. What will happen if the validation if Pending == Country is performed? Exactly, it will return true.

To prevent this, we’ll create a new type specifically for handling status. This type will be based on uint8, but since it’s a distinct type, the validation mentioned earlier will not return true.

type Status uint8

Creating the ENUM

With a new type defined, let’s create the constants and their corresponding values for the registration statuses.

const (
  Created Status = 0
  Pending = 1
  Approved = 2
  Rejected = 3
)

Although there’s nothing inherently wrong with assigning values as we did above, there’s a simpler way. Instead of assigning a value to each constant, we can use the iota keyword. This keyword makes Go assign 0 to the first constant and then increment the value by 1 sequentially for each subsequent constant.

const (
  Created Status = iota
  Pending
  Approved
  Rejected
)

Printing the ENUM

As the enum is currently implemented, printing the constant Created would display the value 0. However, for better readability, it’s more helpful to display the word Created instead of the value 0.

The solution is very simple. Just implement the magic String() method.

func (s Status) String() string {
  switch s {
    case Created:
      return "created"
    case Pending:
      return "pending"
    case Approved:
      return "approved"
    case Rejected:
      return "rejected"
   }

   return "unknown"
}

Conclusion

To test this, let’s do a simple print of the Pending status.

package main

import "fmt"

type Status uint8

const (
  Created Status = iota
  Pending
  Approved
  Rejected
)

func (s Status) String() string {
  switch s {
    case Created:
      return "created"
    case Pending:
      return "pending"
    case Approved:
      return "approved"
    case Rejected:
      return "rejected"
  }

  return "unknown"
}

func main() {
  fmt.Println(Pending)
}

Executing the command go run should output pending on terminal.

That’s it! I hope this was helpful.

See you next time!