Why Doesn't a Go Function Returning a Struct Implementing an Interface Satisfy an Interface-Returning Function Field?

Go Function Types Returning Structs Incompatible with Interfaces

Question:

In Go, why does a function returning a struct that implements an interface not satisfy the type requirement of a field that expects a function returning that interface?

Answer:

The problem lies in the fact that a Go function type that returns a struct is not interchangeable with a function type that returns an interface, even if the struct implements the interface. When declaring a type signature for a function within a struct, the specific return type must match the declared type. Modifying the factory function to return the interface type directly resolves the issue.

Example:

package main

import "fmt"

func main() {
    thing := structToConstruct{getInstance}
    thing.performAction()
}

type myInterface interface {
    doSomething()
}

type structToConstruct struct {
    factoryFunction func() myInterface
}

func (s *structToConstruct) performAction() {
    instance := s.factoryFunction()
    instance.doSomething()
}

func getInstance() myInterface {
    return &myStruct{}
}

type myStruct struct{}

func (m *myStruct) doSomething() {
    fmt.Println("doing something")
}

In this example, the factory function is modified to return an instance of myInterface, which satisfies the type requirement for structToConstruct.

Explanation:

When declaring the structToConstruct type, we specify that factoryFunction should be a function that returns a myInterface. However, the expensive.CreateInstance function returns a *myStruct value, which is not directly assignable to myInterface. This is because Go interfaces provide type safety, and a function that returns a specific struct type (e.g., *myStruct) cannot be automatically converted to a function that returns the interface type it implements.

To use the *myStruct value with myInterface, we must explicitly convert it using type assertion or by creating an adapter function that wraps the conversion:

func wrapper() myInterface {
    return expensive.CreateInstance()
}

thing := structToConstruct{wrapper}

The above is the detailed content of Why Doesn't a Go Function Returning a Struct Implementing an Interface Satisfy an Interface-Returning Function Field?. For more information, please follow other related articles on the PHP Chinese website!