How to Create a Type in Go that Can Take Multiple Types

How would you go about creating your own type that can accept a bool, string or int without using the any interface?

Currently, if you want to support multiple types, say as a value to a HashMap, you can do something like:

data = make(map[string]any)
data["bool"] = true
data["string"] = "string"
data["int"] = 3

And then you can pass this around to functions like:

func doStuff(data map[string]any) {
  ...
}

I have tried the following:

type CustomType interface {
	~int | ~bool | ~string
}

data = make(map[string]CustomType)

But Go will complain that I can't use this outside of a type constraints for generic functions, etc.

This sounds like you're looking for a "sum type". Go doesn't have these, at least not in the proper sense, but you have a few different options for doing something similar:

First: just make a struct that has all the types you want as fields.

type Sum struct {
  I int
  B bool
  S string
}

This will work perfectly well in something like make(map[string]Sum), but any time you want to get the underlying ints, bools, or strings out of this type, you'll have to explicitly ask for the one you want. You also don't have any built-in mechanism to track which type of thing you have in a given value. You could add logic to track that that might look something like:

type Sum struct {
  i int
  isInt bool

  b bool
  isBool bool

  s string
  isString bool
}

func Int(i int) Sum {
  return Sum{i: i, isInt: true}
}

func (s Sum) IsInt() bool {
  return s.IsInt
}

func (s Sum) Int() int {
  if !s.isInt {
    panic("not an int")
  }
  return s.i
}

// Similar Bool() and String() functions.

In theory, if you really really really need every last bit of performance out of this code, you can do some tricks to make this act like a union type in C as described in this question.

Second, you can do something similar, but using interfaces. This post shows how that might work. The advantage to this is the ability to use Go's built-in type-switch syntax to look through and find which kind of value you have.

Third: just keep using any. This is simpler, already built-in, and reasonably efficient. The only downside to using any is that unlike the other options, it's possible to construct values with unexpected types (e.g. you can pass a float into something that accepts any, but you can't create a Sum value from a float).