Defining a named function type that returns any type

I would like to define a function type (what we call delegate in C#) whose return value can be anything (is unknown at compile type) and after reading Go docs I found that the current version of the language does not support generics.

After searching StackOverflow I came across a post suggesting that the return type can be set as interface{} which implies that any type can be returned by that function. Then I wrote the following code to test how it works:

type Consumer func() interface {}

func TestConsumer() Consumer {
    return func() string {
         return "ok"
    }
}

But I got the following error

> cannot use func literal (type func() string) as type Consumer in return argument

This is while when I change the return type of Consumer to string, it works without any problem.

The question is what is that I am doing wrong and how can I achieve writing a function type (delegate) that can return anything and assign an actual functions to that?

The issue is that the function type func() string does not conform to the function type func() interface{}.

The reason for this is because the function type func() interface{} means a function that explicitly returns a value of type interface{}, and while a string can be easily casted to an interface{}, the overall function signatures are not the same.

The correct code would be:

type Consumer func() interface {}

func TestConsumer() Consumer {
    return func() interface{} {
         return "ok"
    }
}

The string gets implicity casted to the interface{} type, and the function signatures are the same.

If you can use Go 1.18, use type parameters to define your own generic named function type. You can then use it in other generic functions and instantiate it with a type parameter, or instantiate it with concrete types when needed:

^{let's say that a function that returns T is called a "producer" though}

type Producer[T any] func() T

// instantiate with concrete type
func TestProducer() Producer[string] {
    return func() string {
         return "ok"
    }
}

// instantiate with type parameter
func TestProducer[T any]() Producer[T] {
    return func() T {
        return *new(T)
    }
}

In the latter case, you'll have to instantiate TestProducer — the general rule being, at some point the type parameters must be known at compile time.

func main() {
    fn := TestProducer[string]()
    foo := fn()
    fmt.Println(foo) // foo is the empty string

    fn2 := TestProducer[uint64]()
    bar := fn2()
    fmt.Println(bar) // bar is 0
}

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

func TestConsumer() interface{} {
    return func() string {
         return "ok"
    }
}

Please try with this one