使用go的struct指针作为接口

Question

I want to pass struct method as function value. Why does compilation fail if function is required to return interface{} and it returns *struct? It perfectly works if I try to return *struct from function that is declared to return interface{} (wrapper func).

package main

func main() {
        println("hello")
        testInterface(wrapper)          // works
        instance := MyStruct{}
        testInterface(instance.works)   // works
        testInterface(instance.fails)   // fails: ./main.go:8: cannot use instance.fails (type func(int) *MyStruct) as type func(int) interface {} in argument to testInterface
}

func testInterface(f func() interface{}) {
        f()
        return
}

type MyStruct struct {
}

func (s *MyStruct) works() interface{} {
        return s
}

func (s *MyStruct) fails() *MyStruct {
        return s
}

func wrapper() interface{} {
        s := MyStruct{}
        return s.fails()

}

Answer 1

That's because it does not fit the assignability criterias

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.

So, this explains why testInterface(instance.fails) fails: because the instance.fails is not assignable to the f func() interface{}.

Now the second question:

It perfectly works if I try to return *struct from function that is declared to return interface{} (wrapper func).

It works fine, because the value of the *struct type is assignable to the interface{} type because of:

1. this rule of the assignability: "T is an interface type and x implements T."
2. "A type implements any interface comprising any subset of its methods and may therefore implement several distinct interfaces. For instance, all types implement the empty interface:" (bold is mine)

References:

• Type identity
• Assignability
• Interface types