Custom type enforcing for Go structs (type any)

I have a question regarding custom types in Go. I'm trying to get some sort of type safety with any. I know union types from TypeScript but as far as I know, union types are not possible in Go. What are viable alternatives?

I want a function or field to have type any because I don't know the type upfront. But I also want to limit possible types so that the compiler complains for unexpected ones.

From what I know, this does work with regular custom types like type x string, etc. but not with struct.

Here is an example with configs:

package main

import "fmt"

type plantConfig any

type treeConfig struct {
	trunkDiameter float64
}

func newTreeConfig(config treeConfig) plantConfig {
	return config
}

type flowerConfig struct {
	color string
}

func newFlowerConfig(config flowerConfig) plantConfig {
	return config
}

// newGarden should only take plantConfig.
func newGarden(config plantConfig) {
	switch config.(type) {
	case treeConfig:
		fmt.Println("planted trees")
	case flowerConfig:
		fmt.Println("planted flowers")
	default:
		fmt.Println("unknown plant")
	}
}

// waterfallConfig is NOT a plantConfig. newGarden should not accept this as
// parameter.
type waterfallConfig struct {
	height float64
}

func main() {
	// This does not report any errors while compiling.
	newGarden(waterfallConfig{})
}

Output:

unknown plant

However, I'd expect the compiler to complain about newGarden(waterfallConfig{}) because waterfallConfig is not of type plantConfig and it should not cast implicitly.
Of course, I could make plantConfig an interface with a method name that is rather "unique" but this does not seem clean to me. Any suggestions? Or am I missing something obvious?

You are on the right track but instead of any (interface{}) you want an interface type that restricts the types you can use. So declare plantConfig like this:

type plantConfig interface{ ImplementsPlant() }

Then you just need to say that the allowed types implement that interface like this:

func (treeConfig) ImplementsPlant() {}

func (flowerConfig) ImplementsPlant() {}

waterfallConfig is of type any. The clue is in the name.

Creating a new type based on any just creates a new symbol representing the empty interface, which all types will match.

The only way I can see to achieve what you want at compile time is to identify some function that all PlantConfig types will implement and have newGarden accept only PlantConfig interfaces.

But as interfaces in Go are duck-typed, rather than formal types, the method(s) of any PlantConfig interface will need to be distinct from any methods that your waterfallConfig might also implement.

You could even use this to simplify other aspects of your code.

Perhaps something like:

type PlantConfig interface {
   func PlantType() string
}

type LandscapeFeatureConfig interface {
   func FeatureType() string
}

// treeConfig implements PlantConfig
type treeConfig struct {}

func (treeConfig) PlantType() string { return "tree" }


// flowerConfig implements PlantConfig
type flowerConfig struct {}

func (flowerConfig) PlantType() string { return "flower" }


// waterfallConfig implements LandscapeFeatureConfig
type waterfallConfig struct {}

func (waterfallConfig) FeatureType() string { return "waterfall" }



func newGarden(cfg PlantConfig) {
   fmt.Printf("planted %s\n", cfg.PlantType())
}

I have imagined that a waterfall is some other configuration type that you may wish to differentiate, calling it a 'Landscape Feature'; a corresponding LandscapeFeatureConfig interface identifies this. This may or may not be suitable in your case, but it is intended as an illustration only.

With that approach, this code will now not compile:

func main() {
    // newGarden will only accept PlantConfig
    newGarden(waterfallConfig{})
}