Singleton pattern with Go generics

I'm trying to work out the least-bad approach for implementing a singleton for a generic variable in Golang. Using the normal sync.Once pattern with a global var is unworkable since generic type information is not available there (below).

This example is contrived, but in practice the code that maintains the singleton could be separate, such as in a library, from the client code that defines T.

Assume this library code, where the concrete value of T is not known:

type Cache[T any] struct{}

var (
	cacheOnce sync.Once
	cache     Cache[any] // Global singleton
)

func getOrCreateCache[T any]() Cache[T] {
	cacheOnce.Do(func() {
		typedCache := buildCache()
		cache = typedCache.(Cache[any]) // Invalid type assertion
	})
	return cache.(Cache[T]) // Invalid type assertion
}

And assume this separate client code, where T is defined as a string:

stringCache := getOrCreateCache[string]()

What's the best approach for accomplishing this?

Generics are supposed to allow parametric polymorphism at compile time, that's the entire point. So a generic singleton seems rather counter-intuitive. There's nothing "generic" in it.

If your goal is to abstract some complex initialization code — that is reusable with different types — into a library, you can use a memoized function. This allows the client code to choose the type parameter when the producer function is called.

// generic singleton type
type Cache[T any] struct {
	value [1024]T
}

type CacheProducer[T any] func() *Cache[T]

func NewProducer[T any]() CacheProducer[T] {
	var cache *Cache[T]
	return func() *Cache[T] {
		if cache != nil {
			fmt.Println("returning cached")
			return cache
		}
		fmt.Println("instantiating")
		cache = &Cache[T]{ /* initialize fields */ }
		return cache
	}
}

And then you use it by storing the producer function in a global variable, and ensuring there's only one using the package init function.

var getInstance CacheProducer[byte]

func init() {
	getInstance = NewProducer[byte]()
}

func main() {
	a := getInstance()
	b := getInstance()
	c := getInstance()

	fmt.Println(a == b) // true (same instance)
	fmt.Println(b == c) // true (same instance)
}

Playground: https://go.dev/play/p/lwWR43zq5D6

You can also use sync.Once if initialization is supposed to occur at a later time in the program execution. The point is that you initialize the producer function instead of the type itself. This doesn't dispense you from choosing a concrete type parameter at the time you write the client code.

You may read more about the difference here: https://stackoverflow.com/questions/51953191/difference-between-init-and-sync-once-in-golang.

I ended up solving this using the atomic.Pointer API, and rolled it into a simple library for others to use if they're interested: singlet. Re-working the original post with singlet looks like this:

Example library code:

type Cache[T any] struct{}

var singleton = &singlet.Singleton{}

func getOrCreateCache[T any]() (Cache[T], err) {
	return singlet.GetOrDo(singleton, func() Cache[T] {
		return Cache[T]{}
	})
}

Client code:

stringCache := getOrCreateCache[string]()

And the Singlet library code that supports this:

var ErrTypeMismatch = errors.New("the requested type does not match the singleton type")

type Singleton struct {
	p   atomic.Pointer[any]
	mtx sync.Mutex
}

func GetOrDo[T any](singleton *Singleton, fn func() T) (result T, err error) {
	maybeResult := singleton.p.Load()
	if maybeResult == nil {
		// Lock to guard against applying fn twice
		singleton.mtx.Lock()
		defer singleton.mtx.Unlock()
		maybeResult = singleton.p.Load()

		// Double check
		if maybeResult == nil {
			result = fn()
			var resultAny any = result
			singleton.p.Store(&resultAny)
			return result, nil
		}
	}

	var ok bool
	result, ok = (*maybeResult).(T)
	if !ok {
		return *new(T), ErrTypeMismatch
	}
	return result, nil
}

I hope that helps anyone else who comes across this situation.