How can I return a subtype of the specified return value (in this case interface{})?

I have an interface that defines one parameter to have type func(interface{}, proto.Message) interface{} and I'm trying to pass something of type func reduceMsg(a interface{}, b proto.Message) []*PersistentData to it. This results in the following compiler error:

Cannot use reduceMsg (type func(a interface{}, b proto.Message) []*PersistentData as type func(interface{}, proto.Message) interface{}

What is the reason for this error, and how can I work around it? It seems like returning a more specific type than interface{} should be legal. Here's a simple complete example that illustrates the issue:

package main

import "fmt"

func main() {
	var t func() interface{} = func() []string { return []string{} }
	fmt.Println(t)
}

The type of the object is the whole function signature. If the signature don't match, then it's not the same type and can't be assigned that way.

Anything can be assigned to the empty interface, because all types satisfy the interface, but in your problem neither type is the empty interface, you just have a function that returns an empty interface.

Not because a part of the function can be assigned to another it makes it the same. The type is the whole function signature. I think it's the same logic behind not being able to assign an int to an int8. You can cast them if you want, but for go, they are separate types and you need to deal with making the necessary conversions to be able to assign them.

What you can do is change your second function signature to return an empty interface like this:

func(interface{}, proto.Message) interface{}

func reduceMsg(a interface{}, b proto.Message) interface{} {
    var a []*PersistentData
    // do something here
    return a
}

This way the function signature is the same, so it's consider the same type and you are returning an []*PersistentData. Of course you will need to do a type assertion before using it as such because the program will treat it as an {}interface because that is the type that the function returned.

Referencing the spec,

>In assignments, each value must be assignable to the type of the operand to which it is assigned, with the following special cases:
>
> * Any typed value may be assigned to the blank identifier.
> * If an untyped constant is assigned to a variable of interface type or the blank identifier, the constant is first converted to its default type.
> * If an untyped boolean value is assigned to a variable of interface type or the blank identifier, it is first converted to type bool.

Assignability

> A value x is assignable to a variable of type T ("x is assignable to T") in any of these cases:
>
> * x's type is identical to T.
> * x's type V and T have identical underlying types and at least one of V or T is not a named type.
> * T is an interface type and x implements T.
> * x is a bidirectional channel value, T is a channel type, x's type V and T have identical element types, and at least one of V or T is not a named type.
> * x is the predeclared identifier nil and T is a pointer, function, slice, map, channel, or interface type.
> * x is an untyped constant representable by a value of type T.

In general, Go doesn't allow you to implicitly convert values from one type to another, with the exception of being able to use concrete-typed objects as though they were interfaces (that they implement).

In this particular case, since your function doesn't actually return an interface{}, the compiler would have to do some extra work to wrap up the return value as an interface{} and return it; if you really want to accomplish what you're trying you can do this explicitly yourself:

type Foo struct {
    X int
}
func create(x int) Foo {
    return Foo{X: x}
}
func main() {
    var f func(int) interface{} = func(x int) interface{} {
        return create(x)
    }
}

which is basically doing (explicitly) the wrapping operation that you want the runtime to do implicitly.