Go – Resolve Type Func with Interface Parameter Incompatibility Error

I have declared a new type func that takes any value that conforms to interface{}. However, when I invoke a function that has been passed as an argument (conforming to that type specification) I get an error.

Can somebody explain why this is the case? Below is the simplest example I could recreate the issue with.

type myfunc func(x interface{})

func a(num int) {
    return
}

func b(f myfunc) {
    f(2)
    return
}

func main() {
    b(a) // error: cannot use a (type func(int)) as type myfunc in argument to b
    return
}

Best Answer

The concept you're looking for here is variance in the type system. Some type systems and types support covariance and contravariance, but Go's interfaces do not.

While an int can be passed to a function that expects interface{}, the same cannot be said about func(int) and func(interface{}), because interfaces do not behave covariantly.

If type x implements interface ii, it doesn't mean that func(x) implements func(ii).

What you could do is pass func(int) into a function that expects interface{}, so you could do

package main

import "fmt"

func foo(x interface{}) {
    fmt.Println("foo", x)
}

func add2(n int) int {
    return n + 2
}

func main() {
    foo(add2)
}

Because func(int)int does implement interface{}.

In addition to the Wikipedia link at the top of the answer, this post provides more details about the different kinds of variance programming languages support. It mostly uses other languages, because variance is best demonstrated with languages that support inheritance.

Related Solutions

Go Generics – How to Use a Type Parameter in an Interface Method

As the error suggests, methods cannot have type parameters of their own as per the latest design. However, they can use the generics from the interface or struct they belong to.

What you need is to specify the type parameter on the interface type as follows:

type Iterator[T any] interface {
    // ...
}

and then use the T as any other type parameter in methods within the interface body. For example:

package main

import "fmt"

type Iterator[T any] interface {
    ForEachRemaining(action func(T) error) error
    // other methods
}

func main() {
    fmt.Println("This program compiles")
}

Try it on Go playground.

Go Interface Type Constraints – Conversion Issues Explained

The language specifications explicitly disallow using interfaces with type elements as anything other than type parameter constraints (the quote is under the paragraph Interface types):

Interfaces that are not basic may only be used as type constraints, or as elements of other interfaces used as constraints. They cannot be the types of values or variables, or components of other, non-interface types.

An interface that embeds comparable or another non-basic interface is also non-basic. Your Number interface contains a union, hence it is non-basic too.

A few examples:

// basic: only methods
type A1 interface {
    GetName() string
}

// basic: only methods and/or embeds basic interface
type B1 interface {
    A1
    SetValue(v int)
}

// non-basic: embeds comparable
type Message interface {
    comparable
    Content() string
}

// non-basic: has a type element (union)
type Number interface {
    int | int64 | float64
}

// non-basic: embeds a non-basic interface
type SpecialNumber interface {
    Number
    IsSpecial() bool
}

In the initialization of the variable a, you are attempting to use Number in a type conversion Number(1), and this is not allowed.

You can only use Number as a type parameter constraint, i.e. to restrict the types allowed for instantiation of a generic type or function. For example:

type Coordinates[T Number] struct {
    x, y T
}

func sum[T Number](a, b T) T {
    return a + b
}

Best Answer

Related Solutions

Go Generics – How to Use a Type Parameter in an Interface Method

Go Interface Type Constraints – Conversion Issues Explained

Related Question